source: other-projects/GlamED/trunk/src/org/honours/agents/ImportCollections.java@ 26756

package org.honours.agents;

import java.awt.*;
import java.io.*;
import java.util.ArrayList;
import java.util.List;

import org.expeditee.actions.Misc;
import org.expeditee.agents.DefaultAgent;
import org.expeditee.items.*;
import org.expeditee.gui.Frame;
import org.expeditee.gui.*;

import org.honours.Main;
import org.honours.collection.*;
import org.honours.greenstone.CollectionConfigReader;
import org.honours.gui.*;

/**
 * This is an Expeditee agent to allow a user
 * to import/move Expeditee framesets generated
 * in Greenstone to the system's "collections" directory.
 * @author Korii
 */
public class ImportCollections extends DefaultAgent {

    //Starting position of displaying rows containing links to access and work with imported collections/framesets.
    private static final int _startX = 75;
    private static final int _startY = 100;
    
    //Declare gap between rows and height of each row.
    private static final int _gap = 30;
    private static final int _rowSize = 60;
    
    //Maximum rows that can be displayed on each frame.
    private static final int _maxRows = 5;
    
    //Main frameset where user accesses imported collections/framesets from.
    private static final String _collectionFramesetName = "collectionsmain";
    
    //GSDL collect directory link.
    private static String _gsdlCollectionsDir = Main.GSDL_HOME + File.separator + "sites" + File.separator + "localsite" + File.separator + "collect" + File.separator;
    
    /**
     * Imports all collections that can be obtained from GSDL and
     * are NOT currently in Expeditee.
     * NOTE: null can be passed to this method as
     * we don't actually rely on a frame for this agent to be run.
     */
    public Frame process(Frame frame) {
        
        File collectDir = new File(_gsdlCollectionsDir);
        
        String[] children = collectDir.list();
        if(children == null){
            MessageBay.errorMessage("No GSDL Collections Could Be Found.");
            return null;
        }
        
        try{
            importEachCollection(children);
        }catch(Exception e){
            e.printStackTrace();
            return null;
        }
        
        MessageBay.displayMessage("Collection Importing Complete!", Color.green);
        return null;
    }
    
    /**
     * Import any collection framesets found in Greenstone into GlamED.
     * @param children
     * @throws Exception
     */
    private static void importEachCollection(String[] children) throws Exception{

        List<Collection> tempCollections = new ArrayList<Collection>();
        Frame getFreeFrame = null;
        Point getFreePoint = null;
        String link = null;
        
        for(int i = 0; i < children.length; i++){
            
            //Name of the GSDL collection
            String collectionName = children[i];
            String filename = _gsdlCollectionsDir + File.separator + collectionName;
            
            File dir = new File(filename);
            
            if(dir.isDirectory()){
                
                File outputDir = new File(filename + File.separator + "export" + File.separator + collectionName);
                
                if(outputDir.isDirectory()){
                    
                    String[] filesToMove = getFiles(outputDir);
                    
                    if(filesToMove == null){
                        String errorMsg = "Failed to import collection: " + collectionName;
                        MessageBay.errorMessage("ERROR: " + errorMsg);
                        throw new Exception(errorMsg);
                    }
                    
                    File matchingFrameset = matchingFrameset(collectionName);

                    //Obtain first free frame for displaying collection row with links
                    Object[] freeFrameInfo = findFreeFrame();
                    getFreeFrame = (Frame)freeFrameInfo[0];
                    getFreePoint = (Point)freeFrameInfo[1];
                    
                    if(getFreeFrame == null){
                        int num = FrameIO.getLastNumber(_collectionFramesetName) + 1;
                        HonoursFrameIO.generateFrame(num,_collectionFramesetName);
                        getFreeFrame = FrameIO.LoadFrame(_collectionFramesetName + FrameIO.getLastNumber(_collectionFramesetName));
                    }
                    
                    link = collectionName + "1";
                    
                    //Import collection into Expeditee.
                    importIntoExpeditee(matchingFrameset,outputDir,collectionName,tempCollections);
                }
            }
        }
        
        for(Collection t : tempCollections){
            Main._collections.add(t);
        }
        
        //Display links for each collection.
        for(Collection c : Main._collections){
            
            for(CollectionItem cItem : c.getItems()){
                System.err.println("Setting up interface for " + cItem.getFrame().getName());
                Interfaces.setUpToolbarOverlay(cItem);
                Interfaces.setUpToggleToolbarOverlay(cItem);
                Interfaces.setUpNotesOverlay(cItem);
                //Interfaces.setUpBox(cItem);
            }
            
            String cName = c.getName();
            
            //Check if a row of links already exists for the current collection.
            boolean linkExists = linkExists(cName);
            System.err.println("Link exists: " + linkExists);
            
            if(!linkExists){
                System.err.println("Adding row of link for collection " + cName);
                displayRowsOfLinks(cName, getFreeFrame, getFreePoint, link);
            }
            
        }

    }

    /**
    * Import current collection into Expeditee from GSDL.
    * @param matchingFrameset - location of an existing matching frameset.
    * @param collectionName - name of the collection to import
    **/
    private static void importIntoExpeditee(File matchingFrameset, File exports, String collectionName, List<Collection> tempCollections){
        
        if(matchingFrameset == null){
            MessageBay.displayMessage("Importing from GSDL: " + collectionName);
            
            //Create new frameset directory.
            //String newPath = HonoursFrameIO.COLLECTIONS_PATH + collectionName;
            String newPath = FrameIO.FRAME_PATH + collectionName;
            
            new File(newPath).mkdir();
            
            matchingFrameset = new File(newPath);
            
            //move frames from export to matching frameset.
            moveFiles(exports,matchingFrameset);
            
            Collection collect = Main.obtainCollectionItems(collectionName);
            
            if(collect.getItems().size() == 0){
                MessageBay.errorMessage("Cannot import collection " + collectionName + ". No items/assocfilepaths could be found.");
                FrameIO.deleteFrameset(collectionName);
            }else{
                tempCollections.add(collect);
            }           
        }
    }
    
    ////////////
    
    /**
     * This method displays rows of links for accessing
     * collections along with options to export collection
     * to GSDL, view a collection space, etc.
     * @param collectionName
     * @param getFreeFrame
     * @param getFreePoint
     * @param link
     */
    private static void displayRowsOfLinks(String collectionName,Frame getFreeFrame, Point getFreePoint, String link) {
        
        CollectionConfigReader ccr = new CollectionConfigReader(collectionName);
        
        String description = ccr.retrieveDescription();
        String fullCollName = ccr.retrieveFullCollectionName();
                
        if(fullCollName != null){
            getFreeFrame.addText(getFreePoint.x, getFreePoint.y, fullCollName, null, link);
        }else{
            getFreeFrame.addText(getFreePoint.x, getFreePoint.y, collectionName, null, link);
        }
        
        //Display collection description retrieved from collectionConfig.xml file - only first 25 words if it's a long description.
        if(description != null){
            description = description.replaceAll("\\<[^>]*>","");
            
            String[] descriptionWords = description.split(" ");
            String outputDescription = "";
        
            if(descriptionWords.length > 25){
            
                for(int i = 0; i < 25; i++){
                    outputDescription += descriptionWords[i] + " ";
                }
                outputDescription += "...";
            
            }else{
                outputDescription = description;
            }
        
            getFreeFrame.addText(getFreePoint.x+250, getFreePoint.y, outputDescription, null);
        }
    }
    
    ////////////
    
    /**
     * Check if a link on the collections list page/frame for the passed
     * collection name exists.
     * @param collectionName
     * @return
     */
    private static boolean linkExists(String collectionName){
        
        //loop through each collections frame looking for link
        for(int j = 1; j <= FrameIO.getLastNumber(_collectionFramesetName);j++){
            
            Frame curr = FrameIO.LoadFrame(_collectionFramesetName + j);
            if(curr == null)
                continue;
            
            List<Item> items = curr.getItems();
            for(Item item : items){
                if(item.hasLink()){
                    if(item.getLink().equals(collectionName + "1")){
                        return true;
                    }
                }
            }
        }
        
        return false;
    }

    ////////////
    
    /**
     * Return a point & a frame
     * @param collectionName
     * @return
     */
    private static Object[] findFreeFrame(){
        
        for(int i = 1; i <= FrameIO.getLastNumber(_collectionFramesetName); i++){
            
            Frame curr = FrameIO.LoadFrame(_collectionFramesetName + i);
            if(curr == null)
                continue;
            
            int y = _startY;
            for(int j = 0; j < _maxRows; j++){
                
                Item check = Misc.getItemAtPosition(_startX, y, curr);
                if(check == null){
                    return new Object[]{curr,new Point(_startX,y)};
                }
                y += _rowSize + _gap;
            }
        }
        
        //otherwise need to go on to next frame (which doesn't exist probably).
        Frame toCreate = FrameIO.LoadFrame(_collectionFramesetName + FrameIO.getLastNumber(_collectionFramesetName)+1);
        
        return new Object[]{toCreate,new Point(_startX,_startY)};
    }
    
    ////////////
    
    private static File matchingFrameset(String collectionName){
        
        String[] framesets = FrameIO.getFramesetList().split("\n");
        
        for(int i = 0; i < framesets.length; i++){
            
            if(framesets[i].equals(collectionName))
                //return new File(HonoursFrameIO.COLLECTIONS_PATH + framesets[i]);
                return new File(FrameIO.FRAME_PATH + framesets[i]);
        }
        
        return null;
    }
    
    ////////////
    
    private static String[] getFiles(File exports){
        
        String[] expFiles = exports.list();
        
        boolean hasZeroFrame = false;
        boolean hasFirstFrame = false;
        boolean hasFrameInf = false;
        
        for(int i = 0; i < expFiles.length; i++){
            
            String s = expFiles[i];
            if(s.equals("0.exp"))
                hasZeroFrame = true;
            
            if(s.equals("1.exp"))
                hasFirstFrame = true;
            
            if(s.equals("frame.inf"))
                hasFrameInf = true;
            
            if(hasZeroFrame && hasFirstFrame && hasFrameInf)
                return expFiles;
        }
        
        return null;
    }
    
    ////////////
    
    private static File getExportDirectory(String filename){
        
        String[] newChildren = new File(filename).list();
        
        for(int j = 0; j < newChildren.length; j++){
            if(newChildren[j].equals("export")){
                    String exportDir = filename + File.separator + "export";
                    System.err.println(exportDir);
                    return new File(exportDir);
            }
        }
        
        return null;
    }
    
    ////////////
    
    /**
     * Method to  copy files from one directory
     * to another.
     * @param src
     * @param dest
     */
    public static void moveFiles(File src, File dest){
        
        //get all files in source/original directory.
        File[] filesToMove = src.listFiles();
        
        for(File f : filesToMove){
            String filename = dest.getAbsolutePath() + File.separator + f.getName();
            
            File newFile = new File(filename);
            
            if(!newFile.exists()){
                
                try{
                    newFile.createNewFile();
                    newFile = new File(filename);
                    
                }catch(Exception e){
                    
                    e.printStackTrace();
                    return;
                }
            }else{
                try{
                newFile.delete();
                newFile.createNewFile();
                newFile = new File(filename);
                }catch(Exception e){
                    e.printStackTrace();
                    return;
                }
            }
            
            InputStream in = null;
            OutputStream out = null;
            
            try{
                in = new FileInputStream(f);
                out = new FileOutputStream(newFile);
                
                //transfer bytes from in to out
                byte[] buf = new byte[1024];
                int len;
                while((len = in.read(buf)) > 0){
                    out.write(buf,0,len);
                }
                in.close();
                out.close();
            }catch(Exception e){
                e.printStackTrace();
                return;
            }
        }
    }

}