/*
 *                 Sun Public License Notice
 * 
 * The contents of this file are subject to the Sun Public License
 * Version 1.0 (the "License"). You may not use this file except in
 * compliance with the License. A copy of the License is available at
 * http://www.sun.com/
 * 
 * The Original Code is NetBeans. The Initial Developer of the Original
 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2003 Sun
 * Microsystems, Inc. All Rights Reserved.
 */

package org.netbeans.core.windows.persistence.convert;

import org.netbeans.core.projects.SessionManager;
import org.netbeans.core.windows.Debug;
import org.netbeans.core.windows.persistence.InternalConfig;
import org.netbeans.core.windows.persistence.PersistenceManager;
import org.openide.ErrorManager;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileSystem;
import org.openide.modules.SpecificationVersion;
import org.openide.util.NbBundle;
import org.openide.xml.XMLUtil;
import org.xml.sax.*;
import org.xml.sax.helpers.DefaultHandler;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.*;

/**
 * Handle loading of old Workspace configuration data (version < 2.0).
 * Read only parts necessary for import.
 *
 * @author Marek Slama
 */

class WorkspaceParserOld {
    
    private static final String INSTANCE_DTD_ID_1_0
        = "-//NetBeans//DTD Workspace Properties 1.0//EN"; // NOI18N
    private static final String INSTANCE_DTD_ID_1_1
        = "-//NetBeans//DTD Workspace Properties 1.1//EN"; // NOI18N
    
    /** Module parent folder */
    private FileObject moduleParentFolder;
    
    /** Module workspace folder. Cached here to get events from filesystem
     * when some children are added. */
    private FileObject moduleWorkspaceFolder;
    
    private PropertyHandler propertyHandler;
    
    private InternalConfig internalConfig;
    
    /** Map of ModeParserOld instances. Used for fast access. */
    private Map modeParserMap = new HashMap(19);
    
    /** Unique mode name from file name */
    private String workspaceName;
    
    public WorkspaceParserOld (String name) {
        this.workspaceName = name;
    }
    
    /** Load mode configuration including all tcrefs. */
    WorkspaceConfigOld load () throws IOException {
        //log("load ENTER" + " ws:" + getName());
        WorkspaceConfigOld wc = new WorkspaceConfigOld();
        readProperties(wc);
        readModes(wc);
        //log("load LEAVE" + " ws:" + getName());
        return wc;
    }
    
    private void readProperties (WorkspaceConfigOld wc) throws IOException {
        log("readProperties ENTER" + " ws:" + getName());
        if (propertyHandler == null) {
            propertyHandler = new PropertyHandler();
        }
        InternalConfig internalCfg = getInternalConfig();
        internalCfg.clear();
        propertyHandler.readData(wc, internalCfg);
        
        /*log("               specVersion: " + internalCfg.specVersion);
        log("        moduleCodeNameBase: " + internalCfg.moduleCodeNameBase);
        log("     moduleCodeNameRelease: " + internalCfg.moduleCodeNameRelease);
        log("moduleSpecificationVersion: " + internalCfg.moduleSpecificationVersion);*/
        
        log("readProperties LEAVE" + " ws:" + getName());
    }
    
    private void readModes (WorkspaceConfigOld wc) throws IOException {
        log("readModes ENTER" + " ws:" + getName());
        
        moduleWorkspaceFolder = moduleParentFolder.getFileObject(getName());
        log("     moduleParentFolder: " + moduleParentFolder);
        log("  moduleWorkspaceFolder: " + moduleWorkspaceFolder);
        if (moduleWorkspaceFolder != null) {
            FileObject [] files = moduleWorkspaceFolder.getChildren();
            for (int i = 0; i < files.length; i++) {
                log("fo[" + i + "]: " + files[i]);
                if ((!files[i].isFolder() && PersistenceManager.MODE_EXT.equals(files[i].getExt())) ||
                     files[i].isFolder()) {
                    //Mode configuration file 'wsmode' or mode folder.
                    ModeParserOld modeParser;
                    if (modeParserMap.containsKey(files[i].getName())) {
                        modeParser = (ModeParserOld) modeParserMap.get(files[i].getName());
                    } else {
                        modeParser = new ModeParserOld(files[i].getName());
                        modeParserMap.put(files[i].getName(), modeParser);
                    }
                    modeParser.setModuleParentFolder(moduleWorkspaceFolder);
                }
            }
        }
        /*for (Iterator it = tcRefParserMap.keySet().iterator(); it.hasNext(); ) {
            ModeParserOld tcRefParser = (ModeParserOld) tcRefParserMap.get(it.next());
            log("tcRefParser: " + tcRefParser.getName()
            + " isInModuleFolder:" + tcRefParser.isInModuleFolder()
            + " isInLocalFolder:" + tcRefParser.isInLocalFolder());
        }*/
        
        List localList = new ArrayList(10);
        for (Iterator it = modeParserMap.keySet().iterator(); it.hasNext(); ) {
            ModeParserOld modeParser = (ModeParserOld) modeParserMap.get(it.next());
            localList.add(modeParser);
        }
        
        List modeCfgList = new ArrayList(localList.size());
        for (int i = 0; i < localList.size(); i++) {
            ModeParserOld modeParser = (ModeParserOld) localList.get(i);
            ModeConfigOld modeCfg;
            try {
                modeCfg = modeParser.load();
            } catch (IOException exc) {
                //If reading of one mode fails we want to log message
                //and continue.
                ErrorManager.getDefault().notify(ErrorManager.INFORMATIONAL, exc);
                continue;
            }
            modeCfgList.add(modeCfg);
        }
        
        wc.modes = (ModeConfigOld [])
            modeCfgList.toArray(new ModeConfigOld[modeCfgList.size()]);
        
        log("readModes LEAVE" + " ws:" + getName());
    }
    
    /** Called from WindowManagerParserOld when Windows folder or Windows/WindowManager
     * folder or workspace folder is deleted from module folder.
     * Removes all instances of ModeParserOld, TCRefParserOld.
     */
    void removeAllModes () {
        log("removeAllModes ws:" + getName());
        for (Iterator it = modeParserMap.keySet().iterator(); it.hasNext(); ) {
            ModeParserOld modeParser = (ModeParserOld) modeParserMap.get(it.next());
            modeParser.removeAllTCRefs(getName());
        }
        modeParserMap.clear();
    }
    
    /** Called from WindowManagerParserOld when Windows folder or Windows/WindowManager
     * folder or workspace folder is deleted from module folder.
     * Removes all instances of ModeParserOld, TCRefParserOld.
     * @param modeName unique name of mode
     */
    void removeMode (String modeName) {
        log("removeMode ws:" + getName() + " mo:" + modeName);
        ModeParserOld modeParser = (ModeParserOld) modeParserMap.get(modeName);
        if (modeParser != null) {
            modeParser.removeAllTCRefs(getName());
            modeParserMap.remove(modeName);
        }
    }
    
    /** Removes TCRefParser from WorkspaceParserOld and cleans wstcref file from local folder.
     * @param modeName unique name of mode
     * @param tcRefName unique name of tcRef
     */
    void removeTCRef (String modeName, String tcRefName) {
        log("removeTCRef ws:" + getName() + " mo:" + modeName
        + " tcRef:" + tcRefName);
        ModeParserOld modeParser = (ModeParserOld) modeParserMap.get(modeName);
        if (modeParser != null) {
            modeParser.removeTCRef(getName(),tcRefName);
        }
    }
    
    /** Called from WindowManagerParserOld when mode is added to module folder.
     * Adds ModeParserOld.
     * @param modeName unique name of mode
     */
    ModeConfigOld addMode (String modeName) {
        log("addMode ENTER" + " mo:" + modeName);
        ModeParserOld modeParser =
            (ModeParserOld) modeParserMap.get(modeName);
        if (modeParser != null) {
            ErrorManager.getDefault().log(ErrorManager.WARNING,
            "[WinSys.WorkspaceParserOld.addMode]" // NOI18N
            + " Warning: ModeParserOld " + modeName // NOI18N
            + " exists but it should not."); // NOI18N
            modeParserMap.remove(modeName);
        }
        modeParser = new ModeParserOld(modeName);
        FileObject moduleWorkspaceFolder = moduleParentFolder.getFileObject(getName());
        modeParser.setModuleParentFolder(moduleWorkspaceFolder);
        modeParserMap.put(modeName, modeParser);
        ModeConfigOld modeConfig = null;
        try {
            modeConfig = modeParser.load();
        } catch (IOException exc) {
            ErrorManager em = ErrorManager.getDefault();
            em.log(ErrorManager.WARNING,
            "[WinSys.WorkspaceParserOld.addMode]" // NOI18N
            + " Warning: Cannot load mode " + modeName); // NOI18N
            em.notify(ErrorManager.INFORMATIONAL, exc);
        }
        return modeConfig;
    }
    
    /** Called from WindowManagerParserOld when wstcref file is added to module folder.
     * Adds TCRefParserOld.
     * @param modeName unique name of mode
     * @param tcRefName unique name of tcRef
     */
    TCRefConfigOld addTCRef (String modeName, String tcRefName) {
        log("addTCRef ENTER" + " ws:" + getName() + " mo:" + modeName
        + " tcRef:" + tcRefName);
        ModeParserOld modeParser = (ModeParserOld) modeParserMap.get(modeName);
        if (modeParser == null) {
            ErrorManager.getDefault().log(ErrorManager.WARNING,
            "[WinSys.WorkspaceParserOld.addTCRef]" // NOI18N
            + " Warning: ModeParserOld " + modeName // NOI18N
            + " does not exist."); // NOI18N
            return null;
        }
        TCRefConfigOld tcRefConfig = modeParser.addTCRef(tcRefName);
        return tcRefConfig;
    }
    
    /** Getter for internal configuration data.
     * @return instance of internal configuration data
     */
    InternalConfig getInternalConfig () {
        if (internalConfig == null) {
            internalConfig = new InternalConfig();
        }
        return internalConfig;
    }
    
    void setModuleParentFolder (FileObject moduleParentFolder) {
        this.moduleParentFolder = moduleParentFolder;
    }
    
    String getName () {
        return workspaceName;
    }
    
    /** Returns instance of TCRefParserOld.
     */
    TCRefParserOld findTCRefParser (String modeName, String tcRefName) {
        ModeParserOld modeParser =
            (ModeParserOld) modeParserMap.get(modeName);
        if (modeParser != null) {
            return modeParser.findTCRefParser(tcRefName);
        } else {
            return null;
        }
    }
    
    void log (String s) {
        Debug.log(WorkspaceParserOld.class, s);
    }
    
    private final class PropertyHandler extends DefaultHandler {
        
        /** Mode configuration data */
        private WorkspaceConfigOld workspaceConfig = null;
        
        /** Internal configuration data */
        private InternalConfig internalConfig = null;
        
        /** xml parser */
        private XMLReader parser;
        
        /** Lock to prevent mixing readData and writeData */
        private final Object RW_LOCK = new Object();
        
        public PropertyHandler () {
        }
        
        private FileObject getConfigFOInput () {
            FileObject fo = moduleParentFolder.getFileObject
            (WorkspaceParserOld.this.getName(), ImportManager.WORKSPACE_EXT);
            
            log("getConfigFOInput" + " fo:" + fo);
            
            FileObject workspaceConfigFO = null;
            if (fo != null) {
                //Look for file at install layer
                SessionManager sm = SessionManager.getDefault();
                FileSystem installLayer = sm.getLayer(SessionManager.LAYER_INSTALL);
                workspaceConfigFO = installLayer.findResource(fo.getPath());
            }
            
            log("getConfigFOInput" + " workspaceConfigFO:" + workspaceConfigFO);
            
            return workspaceConfigFO;
        }
        
        /** 
         Reads mode configuration data from XML file. 
         Data are returned in output params.
         */
        void readData (WorkspaceConfigOld workspaceCfg, InternalConfig internalCfg)
        throws IOException {
            workspaceConfig = workspaceCfg;
            internalConfig = internalCfg;
            
            FileObject cfgFOInput = getConfigFOInput();
            if (cfgFOInput == null) {
                //No configuration data
                //Set name even in such case
                workspaceConfig.name = WorkspaceParserOld.this.getName();
                return;
            }
            try {
                synchronized (RW_LOCK) {
                    //DUMP BEGIN
                    /*if ("explorer".equals(WorkspaceParserOld.this.getName())) {
                        InputStream is = cfgFOInput.getInputStream();
                        byte [] arr = new byte [is.available()];
                        is.read(arr);
                        log("DUMP Mode:");
                        String s = new String(arr);
                        log(s);
                    }*/
                    //DUMP END
                    
                    getXMLParser().parse(new InputSource(cfgFOInput.getInputStream()));
                }
            } catch (SAXException exc) {
                //Turn into annotated IOException
                String msg = NbBundle.getMessage(WorkspaceParserOld.class,
                    "EXC_WorkspaceParse", cfgFOInput);
                IOException ioe = new IOException(msg);
                ErrorManager.getDefault().annotate(ioe, exc);
                throw ioe;
            }
            
            workspaceConfig.initialized = true;
            
            workspaceCfg = workspaceConfig;
            internalCfg = internalConfig;
            
            workspaceConfig = null;
            internalConfig = null;
        }
        
        public void startElement (String nameSpace, String name, String qname, Attributes attrs) throws SAXException {
            if ("workspace".equals(qname)) { // NOI18N
                handleWorkspace(attrs);
            } else if (internalConfig.specVersion.compareTo(new SpecificationVersion("2.0")) == 0) { // NOI18N
                //Parse version 2.0
            } else {
                log("startElement PARSING OLD");
                //Parse version < 2.0
                if ("module".equals(qname)) { // NOI18N
                    handleModule(attrs);
                } else if ("name".equals(qname)) { // NOI18N
                    handleName(attrs);
                }
            }
        }
        
        public void error(SAXParseException ex) throws SAXException  {
            throw ex;
        }
        
        public void fatalError(SAXParseException ex) throws SAXException {
            throw ex;
        }
        
        public void warning(SAXParseException ex) throws SAXException {
            // ignore
        }
        
        /** Reads element "workspace" */
        private void handleWorkspace (Attributes attrs) {
            String version = attrs.getValue("version"); // NOI18N
            if (version != null) {
                internalConfig.specVersion = new SpecificationVersion(version);
            } else {
                ErrorManager.getDefault().log(ErrorManager.WARNING,
                "[WinSys.WorkspaceParserOld.handleWorkspace]" // NOI18N
                + " Warning: Missing attribute \"version\" of element \"workspace\"."); // NOI18N
                internalConfig.specVersion = new SpecificationVersion("1.1"); // NOI18N
            }
        }
        
        /** Reads element "module" and updates mode config content */
        private void handleModule (Attributes attrs) {
            String moduleCodeName = attrs.getValue("name"); // NOI18N
            //Parse code name
            internalConfig.moduleCodeNameBase = null;
            internalConfig.moduleCodeNameRelease = null;
            internalConfig.moduleSpecificationVersion = null;
            if (moduleCodeName != null) {
                int i = moduleCodeName.indexOf('/');
                if (i != -1) {
                    internalConfig.moduleCodeNameBase = moduleCodeName.substring(0, i);
                    internalConfig.moduleCodeNameRelease = moduleCodeName.substring(i + 1);
                    checkReleaseCode(internalConfig);
                } else {
                    internalConfig.moduleCodeNameBase = moduleCodeName;
                }
                internalConfig.moduleSpecificationVersion = attrs.getValue("spec"); // NOI18N
            }
        }

        /** Checks validity of moduleCodeNameRelease field. 
         * Helper method. */
        private void checkReleaseCode (InternalConfig internalConfig) {
            // #24844. Repair the wrongly saved "null" string
            // as release number.
            if("null".equals(internalConfig.moduleCodeNameRelease)) { // NOI18N
                ErrorManager.getDefault().notify(
                    ErrorManager.INFORMATIONAL,
                    new IllegalStateException(
                        "Module release code was saved as null string" // NOI18N
                        + " for module "  + internalConfig.moduleCodeNameBase // NOI18N
                        + "! Repairing.") // NOI18N
                );
                internalConfig.moduleCodeNameRelease = null;
            }
        }
        
        /** Reads element "name" */
        private void handleName (Attributes attrs) throws SAXException {
            String name = attrs.getValue("unique"); // NOI18N
            if (name != null) {
                workspaceConfig.name = name;
                if (!name.equals(WorkspaceParserOld.this.getName())) {
                    ErrorManager.getDefault().log(ErrorManager.WARNING,
                    "[WinSys.WorkspaceParserOld.handleName]" // NOI18N
                    + " Error: Value of attribute \"unique\" of element \"name\"" // NOI18N
                    + " and configuration file name must be the same."); // NOI18N
                    throw new SAXException("Invalid attribute value"); // NOI18N
                }
            } else {
                ErrorManager.getDefault().log(ErrorManager.WARNING,
                "[WinSys.WorkspaceParserOld.handleName]" // NOI18N
                + " Error: Missing required attribute \"unique\" of element \"name\"."); // NOI18N
                throw new SAXException("Missing required attribute"); // NOI18N
            }
        }
        
        public void endDocument() throws SAXException {
        }
        
        public void ignorableWhitespace(char[] values, int param, int param2) 
        throws SAXException {
        }
        
        public void endElement(String str, String str1, String str2)
        throws SAXException {
        }
        
        public void skippedEntity(String str) throws SAXException {
        }
        
        public void processingInstruction(String str, String str1) 
        throws SAXException {
        }
                
        public void endPrefixMapping(String str) throws SAXException {
        }
        
        public void startPrefixMapping(String str, String str1) 
        throws SAXException {
        }
        
        public void characters(char[] values, int param, int param2) 
        throws SAXException {
        }
        
        public void setDocumentLocator(org.xml.sax.Locator locator) {
        }
        
        public void startDocument() throws SAXException {
        }
        
        /** @return Newly created parser with set content handler, errror handler
         * and entity resolver
         */
        private XMLReader getXMLParser () throws SAXException {
            if (parser == null) {
                // get non validating, not namespace aware parser
                parser = XMLUtil.createXMLReader();
                parser.setContentHandler(this);
                parser.setErrorHandler(this);
                parser.setEntityResolver(this);
            }
            return parser;
        }

        /** Implementation of entity resolver. Points to the local DTD
         * for our public ID */
        public InputSource resolveEntity (String publicId, String systemId)
        throws SAXException {
            if (INSTANCE_DTD_ID_1_0.equals(publicId)
             || INSTANCE_DTD_ID_1_1.equals(publicId)) {
                InputStream is = new ByteArrayInputStream(new byte[0]);
                //getClass().getResourceAsStream(INSTANCE_DTD_LOCAL);
//                if (is == null) {
//                    throw new IllegalStateException ("Entity cannot be resolved."); // NOI18N
//                }
                return new InputSource(is);
            }
            return null; // i.e. follow advice of systemID
        }
        
        void log (String s) {
            Debug.log(PropertyHandler.class, s);
        }
    }
    
}