package org.simantics.district.imports.ui;

import java.io.IOException;
import java.util.Collection;
import java.util.Map;

import org.eclipse.jface.dialogs.IPageChangeProvider;
import org.eclipse.jface.dialogs.IPageChangedListener;
import org.eclipse.jface.dialogs.PageChangedEvent;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.wizard.IWizardContainer;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.simantics.Simantics;
import org.simantics.db.ReadGraph;
import org.simantics.db.Resource;
import org.simantics.db.common.request.IndexRoot;
import org.simantics.db.common.request.ReadRequest;
import org.simantics.db.exception.DatabaseException;
import org.simantics.district.imports.DistrictImportUtils;
import org.simantics.district.network.ui.function.Functions;

public class ComponentMappingPage extends WizardPage {
    
    private CSVImportModel model;
    private Composite composite;
    private Composite childComposite;
    protected Map<String, Resource> componentMappings;
    private Collection<String> distinctMappingIvalues;
    private Collection<String> distinctMappingIndexColumnValues;

    public ComponentMappingPage(CSVImportModel model) {
        super("Select component mappings");
        this.model = model;
        setMessage("Select component mappings");
    }

    @Override
    public void createControl(Composite parent) {
        composite = new Composite(parent, SWT.NONE);
        composite.setLayout(new GridLayout(1,false));
        GridDataFactory.fillDefaults().grab(true, true).align(SWT.FILL, SWT.FILL).applyTo(composite);
        
        setControl(composite);
        
        validatePageComplete();
        
        IWizardContainer container = getContainer();
        if (container instanceof IPageChangeProvider) {
            ((IPageChangeProvider) container).addPageChangedListener(new IPageChangedListener() {

                @Override
                public void pageChanged(PageChangedEvent event) {
                    if (container.getCurrentPage().equals(ComponentMappingPage.this)) {
                        ComponentMappingPage.this.updateComponentMappings();
                    }
                }
            });
        }
    }
    
    private void updateComponentMappings() {
        try {
            int mappingIndex = model.getComponentMappingIndex();
            distinctMappingIndexColumnValues = DistrictImportUtils.readDistinctValuesOfColumn(model.getSource(), model.getDelimiter(), mappingIndex);
            
            try {
                Simantics.getSession().sync(new ReadRequest() {
                    
                    @Override
                    public void run(ReadGraph graph) throws DatabaseException {
                        Resource indexRoot = graph.sync(new IndexRoot(model.getParentDiagram()));
                        if (model.isVertexImport())
                            componentMappings = Functions.getVertexMappings(graph, indexRoot);
                        else
                            componentMappings = Functions.getEdgeMappings(graph, indexRoot);
                    }
                });
            } catch (DatabaseException e) {
                e.printStackTrace();
            }
            
            System.out.println(distinctMappingIndexColumnValues);
            if (childComposite != null)
                childComposite.dispose();
            childComposite = new Composite(composite, SWT.NONE);
            childComposite.setLayout(new GridLayout(1,false));
            GridDataFactory.fillDefaults().grab(true, true).align(SWT.FILL, SWT.FILL).applyTo(childComposite);
            
            for (String value : distinctMappingIndexColumnValues) {
                
                Composite newCompo = new Composite(childComposite, SWT.NONE);
                newCompo.setLayout(new GridLayout(2,false));
                GridDataFactory.fillDefaults().grab(true, true).align(SWT.FILL, SWT.FILL).applyTo(newCompo);
                
                Label t = new Label(newCompo, SWT.NONE);
                t.setText(value);
                
                Combo c = new Combo(newCompo, SWT.READ_ONLY);
                c.setItems(componentMappings.keySet().toArray(new String[componentMappings.size()]));
                c.addSelectionListener(new SelectionListener() {
                    
                    @Override
                    public void widgetSelected(SelectionEvent e) {
                        model.setComponentMappings(value, componentMappings.get(c.getItem(c.getSelectionIndex())));
                        validatePageComplete();
                    }
                    
                    @Override
                    public void widgetDefaultSelected(SelectionEvent e) {
                        widgetSelected(e);
                    }
                });
            }
            composite.layout(true, true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void validatePageComplete() {
        Map<String, Resource> currentMappings = model.getComponentMappings();
        if (currentMappings != null && distinctMappingIndexColumnValues != null && currentMappings.keySet().containsAll(distinctMappingIndexColumnValues))
            setPageComplete(true);
        else 
            setPageComplete(false);
    }

}