package org.simantics.district.network.ui.function;

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.SelectionStatusDialog;
import org.simantics.NameLabelUtil;
import org.simantics.Simantics;
import org.simantics.browsing.ui.common.modifiers.EnumeratedValue;
import org.simantics.browsing.ui.common.modifiers.Enumeration;
import org.simantics.browsing.ui.graph.impl.GraphEnumerationModifier;
import org.simantics.databoard.Bindings;
import org.simantics.db.ReadGraph;
import org.simantics.db.Resource;
import org.simantics.db.Session;
import org.simantics.db.WriteGraph;
import org.simantics.db.common.request.IndexRoot;
import org.simantics.db.common.request.ObjectsWithType;
import org.simantics.db.common.request.ReadRequest;
import org.simantics.db.common.request.WriteRequest;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.exception.RuntimeDatabaseException;
import org.simantics.db.exception.ServiceException;
import org.simantics.db.layer0.variable.Variable;
import org.simantics.db.layer0.variable.Variables.Role;
import org.simantics.db.procedure.Procedure;
import org.simantics.diagram.stubs.DiagramResource;
import org.simantics.district.network.ontology.DistrictNetworkResource;
import org.simantics.layer0.Layer0;
import org.simantics.modeling.ModelingResources;
import org.simantics.modeling.ModelingUtils;
import org.simantics.modeling.adapters.NewCompositeActionFactory;
import org.simantics.modeling.typicals.TypicalUtil;
import org.simantics.operation.Layer0X;
import org.simantics.scl.reflection.annotations.SCLValue;
import org.simantics.ui.workbench.action.DefaultActions;
import org.simantics.utils.ui.SWTUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Functions {

    private static final Logger LOGGER = LoggerFactory.getLogger(Functions.class);
    
    private Functions() {
    }

    private static class HasMappingEnumerationModifier extends GraphEnumerationModifier {

        public HasMappingEnumerationModifier(Session session, Resource subject, Resource relation, Enumeration<Resource> enumeration, Resource value) {
            super(session, subject, relation, enumeration, value);
        }

    }

    @SCLValue(type = "ReadGraph -> Resource -> Variable -> b")
    public static Object defaultEdgeMappingModifier(ReadGraph graph, Resource resource, final Variable context) throws DatabaseException {
        Resource diagram = resolveElement(graph, context);
        DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
        return baseMappingModifier(graph, diagram, DN.EdgeDefaultMapping, DN.Mapping_EdgeMapping, context);
    }
    
    @SCLValue(type = "ReadGraph -> Resource -> Variable -> b")
    public static Object defaultVertexMappingModifier(ReadGraph graph, Resource resource, final Variable context) throws DatabaseException {
        System.out.println(graph.getURI(resource));
        System.out.println(context.getURI(graph));
        
        Resource diagram = resolveElement(graph, context);
        DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
        return baseMappingModifier(graph, diagram, DN.VertexDefaultMapping, DN.Mapping_VertexMapping, context);
    }
    
    @SCLValue(type = "ReadGraph -> Resource -> Variable -> b")
    public static Object mappingModifier(ReadGraph graph, Resource resource, final Variable context) throws DatabaseException {
        
        Resource element = resolveElement(graph, context);
        Resource mappingType = resolveMappingType(graph, element);
        return baseMappingModifier(graph, element, DistrictNetworkResource.getInstance(graph).HasMapping, mappingType, context);
    }

    public static Map<String, Resource> getVertexMappings(ReadGraph graph, Resource resource) throws DatabaseException {
        Map<String, Resource> second = getNetworkMappingsByType(graph, resource , DistrictNetworkResource.getInstance(graph).Mapping_VertexMapping);
        return second;
    }

    public static Map<String, Resource> getEdgeMappings(ReadGraph graph, Resource resource) throws DatabaseException {
        Map<String, Resource> second = getNetworkMappingsByType(graph, resource , DistrictNetworkResource.getInstance(graph).Mapping_EdgeMapping);
        return second;
    }
    
    public static Map<String, Resource> getCRSs(ReadGraph graph, Resource resource) throws DatabaseException {
        Map<String, Resource> result = getNetworkMappingsByType(graph, resource, DistrictNetworkResource.getInstance(graph).SpatialRefSystem);
        return result;
        
    }

    public static Map<String, Resource> getNetworkMappingsByType(ReadGraph graph, Resource element, Resource mappingType) throws DatabaseException {
        Resource indexRoot = graph.sync(new IndexRoot(element));
        List<Resource> mappings = ModelingUtils.searchByType(graph, indexRoot, mappingType);
        Map<String, Resource> result = new HashMap<>(mappings.size());
        Layer0 L0 = Layer0.getInstance(graph);
        mappings.forEach(mapping -> {
            try {
                String name = graph.getRelatedValue2(mapping, L0.HasName);
                Resource existing = result.put(name, mapping);
                if (existing != null) {
                    LOGGER.warn("Duplicate mapping name! {} {} and existing is {}", name, mapping, existing);
                }
            } catch (DatabaseException e) {
                e.printStackTrace();
            }
        });
        return result;
    }
    
    private static Object baseMappingModifier(ReadGraph graph, Resource element, Resource property, Resource mappingType, Variable context) throws DatabaseException {
        Resource indexRoot = graph.sync(new IndexRoot(element));
        List<Resource> mappings = ModelingUtils.searchByType(graph, indexRoot, mappingType);
        Enumeration<Resource> enums = Enumeration
                .make(mappings.stream().map(m -> createEnumeratedValue(graph, m)).collect(Collectors.toList()));
        
        Resource currentMapping = graph.getSingleObject(element, property);
        
        return new HasMappingEnumerationModifier(Simantics.getSession(), element, property, enums, currentMapping);
    }
    
    private static Resource resolveMappingType(ReadGraph graph, Resource element) throws DatabaseException {
        DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
        if (graph.isInstanceOf(element, DN.Edge))
            return DN.Mapping_EdgeMapping;
        else if (graph.isInstanceOf(element, DN.Vertex))
            return DN.Mapping_VertexMapping;
        throw new IllegalStateException("No mapping type found for element " + element + " : " + graph.getPossibleURI(element));
    }

    private static Resource resolveElement(ReadGraph graph, Variable variable) throws DatabaseException {
        Role role = variable.getPossibleRole(graph);
        if (role.equals(Role.PROPERTY))
            return resolveElement(graph, variable.getParent(graph));
        else
            return variable.getRepresents(graph);
    }

    private static EnumeratedValue<Resource> createEnumeratedValue(ReadGraph graph, Resource resource) {
        try {
            String label = NameLabelUtil.modalName(graph, resource);
            return new EnumeratedValue<Resource>(label, resource);
        } catch (DatabaseException e) {
            throw new RuntimeDatabaseException(e);
        }
    }
    
    @SCLValue(type = "ReadGraph -> Resource -> a -> b")
    public static Object enumerationValues(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
        Variable var = (Variable) context;
        System.out.println(graph.getURI(resource));
        System.out.println(var.getURI(graph));
        return Collections.emptyList();
    }
    
    @SCLValue(type = "ReadGraph -> Resource -> a -> b")
    public static Object convertToValue(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
        return graph.getRelatedValue2(resource, Layer0.getInstance(graph).HasName, Bindings.STRING);
//        return null;
    }
    
    
    @SCLValue(type = "Resource -> String -> Resource -> Resource")
    public static Resource compositeInstantiator(final Resource compositeType, final String defaultName, final Resource target) throws DatabaseException {
        
        return TypicalUtil.syncExec(procedure -> {
            if (!SWTUtils.asyncExec(PlatformUI.getWorkbench().getDisplay(), () -> {
                try {
                    queryInitialValuesAndCreateComposite(compositeType, target, defaultName, procedure);
                } catch (Throwable t) {
                    procedure.exception(t);
                }
            })) {
                procedure.execute(null);
            }
        });
    }

    private static class DefaultMappingsDialog extends SelectionStatusDialog {

        private Combo vertexMappingCombo;
        private Combo edgeMappingCombo;
        private Combo crsCombo;
        private Composite composite;
        
        private Resource configuration;
        private Map<String, Resource> vertexMappings = new HashMap<>();
        private Map<String, Resource> edgeMappings = new HashMap<>();
        private Map<String, Resource> composites = new HashMap<>();
        private Map<String, Resource> crss = new HashMap<>();
        private Map<String, Map<String, Resource>> components = new HashMap<>();
        
        private Resource defaultVertexMapping;
        private Resource defaultEdgeMapping;
        private Resource defaultCRS;
        
        private Combo compositeMappingCombo;
        private Combo componentMappingCombo;

        protected DefaultMappingsDialog(Shell parentShell, Resource configuration) {
            super(parentShell);
            this.configuration = configuration;
            setTitle("Select mappings for new DN diagram");
        }

        public Resource getDefaultVertexMapping() {
            return defaultVertexMapping;
        }

        public Resource getDefaultEdgeMapping() {
            return defaultEdgeMapping;
        }

        @Override
        protected Control createDialogArea(Composite parent) {
            composite = (Composite) super.createDialogArea(parent);
            
            createMappingsGroup(composite);
            createExistingCompositeGroup(composite);
            createCRSSettingsGroup(composite);
            
            // compute default values
            Simantics.getSession().asyncRequest(new ReadRequest() {

                @Override
                public void run(ReadGraph graph) throws DatabaseException {
                    
                    vertexMappings = getVertexMappings(graph, configuration);
                    edgeMappings = getEdgeMappings(graph, configuration);
                    
                    composites = getComposites(graph, configuration);
                    if (composites.size() > 0) {
                        components = getComponents(graph, composites.get(0));
                    }
                    
                    crss = getCRSs(graph, configuration);
                    
                    composite.getDisplay().asyncExec(() -> {
                        
                        vertexMappingCombo.setItems(vertexMappings.keySet().toArray(new String[vertexMappings.size()]));
                        edgeMappingCombo.setItems(edgeMappings.keySet().toArray(new String[edgeMappings.size()]));
                        
                        crsCombo.setItems(crss.keySet().toArray(new String[crss.size()]));
                        
                        compositeMappingCombo.setItems(composites.keySet().toArray(new String[composites.size()]));
                        vertexMappingCombo.select(0);
                        edgeMappingCombo.select(0);
                        
                        crsCombo.select(0);
                        
                        if (!composites.isEmpty())
                            compositeMappingCombo.select(0);
                    }); 
                    
                }
            });
            return composite;
        }
        
        protected Map<String, Map<String, Resource>> getComponents(ReadGraph graph, Resource resource) {
            // TODO Auto-generated method stub
            return null;
        }

        protected Map<String, Resource> getComposites(ReadGraph graph, Resource element) throws DatabaseException {
            
            Resource indexRoot = graph.sync(new IndexRoot(element));
            List<Resource> diagrams = ModelingUtils.searchByType(graph, indexRoot, DiagramResource.getInstance(graph).Diagram);
            
            List<Resource> nonDistrictComposites = composites.values().stream().filter(comp -> {
                try {
                    return !graph.isInstanceOf(comp, DistrictNetworkResource.getInstance(graph).Composite);
                } catch (ServiceException e1) {
                    LOGGER.error("Could not check if composite " + comp + " is instanceOf DistrictNetwork.composite");
                    return false;
                }
            }).collect(Collectors.toList());
            Map<String, Resource> result = new HashMap<>(nonDistrictComposites.size());
            Layer0 L0 = Layer0.getInstance(graph);
            nonDistrictComposites.forEach(mapping -> {
                try {
                    String name = graph.getRelatedValue2(mapping, L0.HasName);
                    result.put(name, mapping);
                } catch (DatabaseException e) {
                    LOGGER.error("Could not read name of " + mapping, e);
                }
            });
            return result;
        }

        private void createMappingsGroup(Composite parent) {
            Group group= new Group(parent, SWT.NONE);
            group.setFont(parent.getFont());
            group.setText("Default mappings");
            GridDataFactory.fillDefaults().grab(true, false).applyTo(group);
            group.setLayout(new GridLayout(1, false));
            
            Composite cmposite = new Composite(group, SWT.NONE);
            cmposite.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false));
            cmposite.setLayout(new GridLayout(2, false));
            
            Label vertexMappingLabel = new Label(cmposite, SWT.NONE);
            vertexMappingLabel.setText("Default vertex mapping");

            vertexMappingCombo = new Combo(cmposite, SWT.READ_ONLY | SWT.BORDER);
            GridDataFactory.fillDefaults().grab(true, false).applyTo(vertexMappingCombo);
            
            Label edgeMappingLabel = new Label(cmposite, SWT.NONE);
            edgeMappingLabel.setText("Default edge mapping");

            edgeMappingCombo = new Combo(cmposite, SWT.READ_ONLY | SWT.BORDER);
            GridDataFactory.fillDefaults().grab(true, false).applyTo(edgeMappingCombo);
        }
        
        private void createExistingCompositeGroup(Composite parent) {
            Group group= new Group(parent, SWT.NONE);
            group.setFont(parent.getFont());
            group.setText("Mapped composite");
            GridDataFactory.fillDefaults().grab(true, false).applyTo(group);
            group.setLayout(new GridLayout(1, false));
            
            Composite cmposite = new Composite(group, SWT.NONE);
            cmposite.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false));
            cmposite.setLayout(new GridLayout(2, false));
            
            Label compositeMappingLabel = new Label(cmposite, SWT.NONE);
            compositeMappingLabel.setText("Select composite");

            compositeMappingCombo = new Combo(cmposite, SWT.READ_ONLY | SWT.BORDER);
            GridDataFactory.fillDefaults().grab(true, false).applyTo(compositeMappingCombo);
            compositeMappingCombo.addSelectionListener(new SelectionAdapter() {
                
                @Override
                public void widgetSelected(SelectionEvent e) {
                    super.widgetSelected(e);
                    recalculateMappapleComponents();
                }
            });
            
            Label compojnentMappingLabel = new Label(cmposite, SWT.NONE);
            compojnentMappingLabel.setText("Select component");
            
            componentMappingCombo = new Combo(cmposite, SWT.READ_ONLY | SWT.BORDER);
            GridDataFactory.fillDefaults().grab(true, false).applyTo(componentMappingCombo);
        }
        
        protected void recalculateMappapleComponents() {
            Simantics.getSession().asyncRequest(new ReadRequest() {
                
                @Override
                public void run(ReadGraph graph) throws DatabaseException {
                    
                    
                    composite.getDisplay().asyncExec(() -> {
                        
                    }); 
                }
            });
        }

        private void createCRSSettingsGroup(Composite parent) {
            Group group= new Group(parent, SWT.NONE);
            group.setFont(parent.getFont());
            group.setText("CRS settings");
            GridDataFactory.fillDefaults().grab(true, false).applyTo(group);
            group.setLayout(new GridLayout(1, false));
            
            Composite cmposite = new Composite(group, SWT.NONE);
            cmposite.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false));
            cmposite.setLayout(new GridLayout(2, false));
            
            Label vertexMappingLabel = new Label(cmposite, SWT.NONE);
            vertexMappingLabel.setText("Default CRS");

            crsCombo = new Combo(cmposite, SWT.READ_ONLY | SWT.BORDER);
            GridData textData = new GridData(SWT.FILL, SWT.CENTER, true, false);
            crsCombo.setLayoutData(textData);
        }
        

        @Override
        protected void computeResult() {
            defaultVertexMapping = vertexMappings.get(vertexMappingCombo.getItem(vertexMappingCombo.getSelectionIndex()));
            defaultEdgeMapping = edgeMappings.get(edgeMappingCombo.getItem(edgeMappingCombo.getSelectionIndex()));
            defaultCRS = crss.get(crsCombo.getItem(crsCombo.getSelectionIndex()));
        }

        public Resource getCRS() {
            return defaultCRS;
        }
        
    }
    
    private static void queryInitialValuesAndCreateComposite(final Resource compositeType, final Resource target,
            String defaultName, final Procedure<Resource> procedure) {
        DefaultMappingsDialog dialog = new DefaultMappingsDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), target);

        if (dialog.open() != Dialog.OK) {
            procedure.execute(null);
            return;
        }
        Simantics.getSession().asyncRequest(
                NewCompositeActionFactory.createCompositeRequest(target, defaultName, compositeType),
                new Procedure<Resource>() {
                    @Override
                    public void execute(Resource composite) {
                        Simantics.getSession().asyncRequest(new WriteRequest() {
                            
                            @Override
                            public void perform(WriteGraph graph) throws DatabaseException {
                                DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
                                Resource diagram = graph.getSingleObject(composite, ModelingResources.getInstance(graph).CompositeToDiagram);
                                graph.claim(diagram, DN.EdgeDefaultMapping, dialog.getDefaultEdgeMapping());
                                graph.claim(diagram, DN.VertexDefaultMapping, dialog.getDefaultVertexMapping());
                                graph.claim(diagram, DN.HasSpatialRefSystem, dialog.getCRS());
                                
                                // Generated name prefix from composite name
                                String compositeName = graph.getRelatedValue2(composite, Layer0.getInstance(graph).HasName, Bindings.STRING);
                                graph.claimLiteral(diagram, Layer0X.getInstance(graph).HasGeneratedNamePrefix, "N" + compositeName.substring(compositeName.length() - 1, compositeName.length()));
                            }
                        });
                        DefaultActions.asyncPerformDefaultAction(Simantics.getSession(), composite, false, false, true);
                        procedure.execute(composite);
                    }

                    @Override
                    public void exception(Throwable t) {
                        LOGGER.error("Failed to create composite, see exception for details.", t);
                        procedure.exception(t);
                    }
                });
    }

    public static Collection<Resource> getDistrictDiagrams(ReadGraph graph) throws DatabaseException {
        Layer0 L0 = Layer0.getInstance(graph);
        Collection<Resource> indexRoots = graph.sync(new ObjectsWithType(Simantics.getProjectResource(), L0.ConsistsOf, L0.IndexRoot));
        DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
        Set<Resource> results = new HashSet<>();
        for (Resource indexRoot : indexRoots) {
            Collection<Resource> diagrams = ModelingUtils.searchByType(graph, indexRoot, DN.Diagram);
            results.addAll(diagrams);
        }
        return results;
    }
}