package org.simantics.modeling.utils;

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

import org.simantics.databoard.Bindings;
import org.simantics.db.ReadGraph;
import org.simantics.db.Resource;
import org.simantics.db.common.NamedResource;
import org.simantics.db.common.utils.CommonDBUtils;
import org.simantics.db.common.utils.NameUtils;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.layer0.variable.Variable;
import org.simantics.db.layer0.variable.Variables;
import org.simantics.graphfile.ontology.GraphFileResource;
import org.simantics.layer0.Layer0;
import org.simantics.structural.stubs.StructuralResource2;
import org.simantics.structural2.variables.Connection;
import org.simantics.structural2.variables.VariableConnectionPointDescriptor;
import org.simantics.utils.FileUtils;

public class DumpOntologyStructure {

    private Resource ontology;
    
    private Set<Resource> containers = new HashSet<>(); 
    private Set<Resource> folders = new HashSet<>();
    private Map<Resource, String> names = new HashMap<>();
    private Map<Resource,Resource> parents = new HashMap<>();
    private Map<Resource, File> libraryFolders = new HashMap<>();
    private Set<Resource> modules = new HashSet<>();
    private Map<Resource, String> moduleCodes = new HashMap<>();
    private Set<Resource> pgraphs = new HashSet<>();
    private Map<Resource, String> pgraphCodes = new HashMap<>();
    private Set<Resource> graphFiles = new HashSet<>();
    private Map<Resource, byte[]> graphFileBytes = new HashMap<>();
    private Set<Resource> componentTypes = new HashSet<>();
    private Map<Resource, String> componentTypeDumps = new HashMap<>();
    private Set<Resource> components = new HashSet<>();
    private Map<Resource, String> componentDumps = new HashMap<>();

    private void readNameAndParent(ReadGraph graph, Resource container, Resource r) throws DatabaseException {
        parents.put(r, container);
        names.put(r, NameUtils.getSafeName(graph, r));
    }
    
    private void readLibraries(ReadGraph graph, Resource container) throws DatabaseException {
        Layer0 L0 = Layer0.getInstance(graph);
        for(Resource r : CommonDBUtils.objectsWithType(graph, container, L0.ConsistsOf, L0.Library)) {
            folders.add(r);
            names.put(r, NameUtils.getSafeName(graph, r));
            parents.put(r, container);
            readNameAndParent(graph, container, r);
            readLibraries(graph, r);
        }
        containers.addAll(folders);
    }
    
    private void readComponentTypes(ReadGraph graph) throws DatabaseException {
        Layer0 L0 = Layer0.getInstance(graph);
        StructuralResource2 STR = StructuralResource2.getInstance(graph);
        for(Resource container : containers) {
            for(Resource r : CommonDBUtils.objectsWithType(graph, container, L0.ConsistsOf, STR.ComponentType)) {
                folders.add(r);
                componentTypes.add(r);
                readNameAndParent(graph, container, r);
                ComponentTypePropertiesResult data = graph.syncRequest(new HeadlessComponentTypePropertiesResultRequest(r));
                StringBuilder dump = new StringBuilder();
                for(ComponentTypeViewerPropertyInfo pi : data.getProperties()) {
                    dump.append(pi.name);
                    dump.append(" ");
                    dump.append(pi.type);
                    dump.append(" ");
                    dump.append(pi.defaultValue);
                    if(pi.unit != null) {
                        dump.append(" ");
                        dump.append(pi.unit);
                    }
                    dump.append(" ");
                    dump.append(pi.label);
                    if(pi.description != null) {
                        dump.append(" ");
                        dump.append(pi.description);
                    }
                    dump.append("\n");
                }
                for(NamedResource nr : data.getConnectionPoints()) {
                    dump.append("cp ");
                    dump.append(nr.getName());
                    dump.append("\n");
                }
                componentTypeDumps.put(r, dump.toString());
            }
        }
        containers.addAll(folders);
    }

    private void readComposites(ReadGraph graph) throws DatabaseException {
        Layer0 L0 = Layer0.getInstance(graph);
        StructuralResource2 STR = StructuralResource2.getInstance(graph);
        for(Resource container : containers) {
            for(Resource r : CommonDBUtils.objectsWithType(graph, container, L0.ConsistsOf, STR.Composite)) {
                folders.add(r);
                readNameAndParent(graph, container, r);
            }
        }
        containers.addAll(folders);
    }

    private void readComponents(ReadGraph graph) throws DatabaseException {
        Layer0 L0 = Layer0.getInstance(graph);
        StructuralResource2 STR = StructuralResource2.getInstance(graph);
        for(Resource container : containers) {
            for(Resource r : CommonDBUtils.objectsWithType(graph, container, L0.ConsistsOf, STR.Component)) {
                if(folders.contains(r))
                    continue;
                components.add(r);
                readNameAndParent(graph, container, r);
                Variable v = Variables.getVariable(graph, r);
                TreeMap<String,Variable> properties = new TreeMap<>();
                for(Variable property : v.getProperties(graph))
                    properties.put(property.getName(graph), property);
                StringBuilder dump = new StringBuilder();
                for(Variable property : properties.values()) {
                    String possibleValue = property.getPossiblePropertyValue(graph, "HasDisplayValue", Bindings.STRING);
                    if(possibleValue != null) {
                        dump.append(property.getName(graph));
                        dump.append(" ");
                        dump.append(possibleValue);
                        dump.append("\n");
                    }
                    if(property.getClassifications(graph).contains(StructuralResource2.URIs.ConnectionRelation)) {
                        dump.append(property.getName(graph));
                        Connection c = property.getValue(graph);
                        for(VariableConnectionPointDescriptor desc : c.getConnectionPointDescriptors(graph, null)) {
                            dump.append(" ");
                            dump.append(desc.getRelativeRVI(graph, v));
                        }
                        dump.append("\n");
                    }
                }
                componentDumps.put(r, dump.toString());
            }
        }
    }

    private void readSCLModules(ReadGraph graph) throws DatabaseException {
        Layer0 L0 = Layer0.getInstance(graph);
        for(Resource container : containers) {
            for(Resource r : CommonDBUtils.objectsWithType(graph, container, L0.ConsistsOf, L0.SCLModule)) {
                String code = graph.getPossibleRelatedValue(r, L0.SCLModule_definition, Bindings.STRING);
                if(code != null) {
                    moduleCodes.put(r, code);
                }
                modules.add(r);
                readNameAndParent(graph, container, r);
            }
        }
    }
    
    private void readPGraphs(ReadGraph graph) throws DatabaseException {
        Layer0 L0 = Layer0.getInstance(graph);
        for(Resource container : containers) {
            for(Resource r : CommonDBUtils.objectsWithType(graph, container, L0.ConsistsOf, L0.PGraph)) {
                String code = graph.getPossibleRelatedValue(r, L0.PGraph_definition, Bindings.STRING);
                if(code != null) {
                    pgraphCodes.put(r, code);
                }
                pgraphs.add(r);
                readNameAndParent(graph, container, r);
            }
        }
    }

    private void readGraphFiles(ReadGraph graph) throws DatabaseException {
        Layer0 L0 = Layer0.getInstance(graph);
        GraphFileResource GF = GraphFileResource.getInstance(graph);
        for(Resource container : containers) {
            for(Resource r : CommonDBUtils.objectsWithType(graph, container, L0.ConsistsOf, GF.File)) {
                byte[] bytes = graph.getPossibleRelatedValue(r, GF.HasFiledata, Bindings.BYTE_ARRAY);
                if(bytes != null) {
                    graphFileBytes.put(r, bytes);
                }
                graphFiles.add(r);
                readNameAndParent(graph, container, r);
            }
        }
    }

    public void read(ReadGraph graph, Resource ontology) throws DatabaseException {
        this.ontology = ontology;
        containers.add(ontology);
        readLibraries(graph, ontology);
        readComponentTypes(graph);
        readComposites(graph);
        readComponents(graph);
        readSCLModules(graph);
        readPGraphs(graph);
        readGraphFiles(graph);
    }
    
    private File escapeFile(File file) {

        if(file.exists())
            return file;
        
        return new File(escapeFile(file.getParentFile()), FileUtils.escapeFileName(file.getName()));
        
    }
    
    public void write(File unsafeFolder) throws IOException {
        File folder = escapeFile(unsafeFolder);
        if(folder.exists())
            FileUtils.deleteAll(folder);
        folder.mkdirs();
        writeLibraries(folder);
        writeSCLModules(folder);
        writePGraphs(folder);
        writeGraphFiles(folder);
        writeComponentTypes(folder);
        writeComponents(folder);
    }
    
    private File getFolder(File root, Resource library) {
        if(ontology.equals(library))
            return root;
        Resource parent = parents.get(library);
        File parentFolder = getFolder(root, parent);
        return new File(parentFolder, FileUtils.escapeFileName(names.get(library))); 
    }
    
    private File getParentFolder(File root, Resource r) {
        Resource parent = parents.get(r);
        return getFolder(root, parent);
    }

    private File getFile(File root, Resource r) {
        return new File(getParentFolder(root, r), FileUtils.escapeFileName(names.get(r)));
    }

    private void writeLibraries(File rootFolder) {
        for(Resource library : folders) {
            File folder = getFolder(rootFolder, library);
            folder.mkdirs();
            libraryFolders.put(library, folder);
        }
    }
    
    private void writeSCLModules(File rootFolder) throws IOException {
        for(Resource r : modules) {
            FileUtils.writeFile(getFile(rootFolder, r), moduleCodes.get(r).getBytes());
        }
    }
    
    private void writePGraphs(File rootFolder) throws IOException {
        for(Resource r : pgraphs) {
            FileUtils.writeFile(getFile(rootFolder, r), pgraphCodes.get(r).getBytes());
        }
    }

    private void writeGraphFiles(File rootFolder) throws IOException {
        for(Resource r : graphFiles) {
            FileUtils.writeFile(getFile(rootFolder, r), graphFileBytes.get(r));
        }
    }

    private void writeComponentTypes(File rootFolder) throws IOException {
        for(Resource r : componentTypes) {
            File folder = getFolder(rootFolder, r);
            File file = new File(folder, "__interface__");
            FileUtils.writeFile(file, componentTypeDumps.get(r).getBytes());
        }
    }

    private void writeComponents(File rootFolder) throws IOException {
        for(Resource r : components) {
            FileUtils.writeFile(getFile(rootFolder, r), componentDumps.get(r).getBytes());
        }
    }
    
}