package org.simantics.district.imports.ui;

import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.apache.commons.csv.CSVRecord;
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.layout.TableColumnLayout;
import org.eclipse.jface.viewers.ColumnWeightData;
import org.eclipse.jface.wizard.IWizardContainer;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;
import org.geotools.referencing.CRS;
import org.simantics.district.imports.ui.controls.DynamicComboFieldEditor;

public class CSVImportWizardPage extends WizardPage {

    private CSVImportModel model;

    private Map<Integer, String> headerIndexAndValues = new HashMap<>();

    private Table headerTable;
//    private Button firstAsHeader;

    private Combo delimiterCombo;
    private TableColumnLayout tableColumnLayout;
    private Composite tableComposite;
//    private FileSelectionWidget wktFileSelection;

    // Common for vertex and edge
    private DynamicComboFieldEditor componentMappingSelector;
    private DynamicComboFieldEditor labelSelector;
    
    // For vertex import
    private DynamicComboFieldEditor xCoordSelector;
    private DynamicComboFieldEditor yCoordSelector;
    private DynamicComboFieldEditor zValueSelector;

    // For edge import
    private DynamicComboFieldEditor startXCoordSelector;
    private DynamicComboFieldEditor startYCoordSelector;
    private DynamicComboFieldEditor startZValueSelector;
    private DynamicComboFieldEditor endXCoordSelector;
    private DynamicComboFieldEditor endYCoordSelector;
    private DynamicComboFieldEditor endZValueSelector;
    private DynamicComboFieldEditor tempValueSelector;
    private DynamicComboFieldEditor pressureValueSelector;
    
    private DynamicComboFieldEditor outerDiameterSelector;
    private DynamicComboFieldEditor diameterSelector;
    private DynamicComboFieldEditor nominalMassFlowSelector;

    private Group indexMappingGroup;

    private Composite composite;

    private Button isVertexImport;

    private Combo sourceCRSCombo;
    
    protected CSVImportWizardPage(CSVImportModel model) {
        super("Import CSV Data");
        this.model = model;
        setMessage("Select column index 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);

        Label label = new Label(composite, SWT.NONE);
        label.setText("Select delimiter");
        
        delimiterCombo = new Combo(composite, SWT.DROP_DOWN | SWT.READ_ONLY);
        delimiterCombo.setToolTipText("Select the delimiter that is used to separate elements in the CSV file");
        delimiterCombo.setItems(model.getDelimiterFormats());
        delimiterCombo.addSelectionListener(new SelectionListener() {

            @Override
            public void widgetSelected(SelectionEvent e) {
                model.setDelimiterByLabel(delimiterCombo.getItem(delimiterCombo.getSelectionIndex()));
                updateHeaders();
                updateCombos();
            }

            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
                widgetSelected(e);
            }
        });

//        firstAsHeader = new Button(composite, SWT.CHECK);
//        firstAsHeader.setText("Read first row as header");
//        firstAsHeader.setSelection(model.getReadFirstAsHeader());
//        firstAsHeader.addSelectionListener(new SelectionListener() {
//
//            @Override
//            public void widgetSelected(SelectionEvent e) {
//                model.setReadFirstAsHeader(firstAsHeader.getSelection());
//                updateHeaders();
//                updateCombos();
//            }
//
//            @Override
//            public void widgetDefaultSelected(SelectionEvent e) {
//                widgetSelected(e);
//            }
//        });

        tableComposite = new Composite(composite, SWT.BORDER);
        tableColumnLayout = new TableColumnLayout();
        tableComposite.setLayout(tableColumnLayout);

        label = new Label(composite, SWT.NONE);
        label.setText("Select source Coordinate Reference System");
        
        sourceCRSCombo = new Combo(composite, SWT.NONE);
        sourceCRSCombo.setToolTipText("Select the coordinate reference system that is used in the source material for possible transformation to target coordinate reference system (EPSG:4326)");
        Set<String> codes = CRS.getSupportedCodes("EPSG");
        sourceCRSCombo.setItems(codes.toArray(new String[codes.size()]));
        sourceCRSCombo.addSelectionListener(new SelectionAdapter() {
            
            @Override
            public void widgetSelected(SelectionEvent e) {
                String current = sourceCRSCombo.getItem(sourceCRSCombo.getSelectionIndex());
                model.setSourceCRS("EPSG:" + current);
            }
        });
        
        sourceCRSCombo.addModifyListener(new ModifyListener() {
            
            @Override
            public void modifyText(ModifyEvent e) {
                String currentText = sourceCRSCombo.getText();
                if (codes.contains(currentText)) {
                    // Select this
                    String[] items = sourceCRSCombo.getItems();
                    int i;
                    for (i = 0; i < items.length; i++) {
                        String item = items[i];
                        if (currentText.equals(item)) {
                            break;
                        }
                    }
                    if (i != 0) {
                        sourceCRSCombo.select(i);
                        model.setSourceCRS("EPSG:" + currentText);
                    } else {
                        System.err.println("this should not happen");
                    }
                }
            }
        });
        
//        wktFileSelection = new FileSelectionWidget(composite, "WKT file", SWT.OPEN);
//        wktFileSelection.addListener(new FileSelectionListener() {
//
//            @Override
//            public void fileSelected(FileOrDirectorySelectionWidget source, String[] filename) {
//                String[] selection = wktFileSelection.getFilename();
//                if (selection != null && selection.length > 0) {
//                    Path wktFile = Paths.get(selection[0]);
//                    if (!Files.exists(wktFile)) {
//                        setErrorMessage("File " + wktFile.toAbsolutePath() + " does not exist");
//                    } else {
//                        model.setWKTFile(wktFile);
//                        validatePageComplete();
//                    }
//                }
//            }
//        });

        isVertexImport = new Button(composite, SWT.CHECK);
        isVertexImport.setText("File contains vertices");
        isVertexImport.setToolTipText("Enable this if the file contains vertices, i.e. points");
        isVertexImport.setSelection(model.isVertexImport());
        isVertexImport.addSelectionListener(new SelectionListener() {

            @Override
            public void widgetSelected(SelectionEvent e) {
                model.setVertexImport(isVertexImport.getSelection());
                updateControls(false);
            }

            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
                widgetSelected(e);
            }
        });
        
        updateControls(true);
        updateHeaders();
        setControl(composite);

        final IWizardContainer container = getContainer();
        
        if (container instanceof IPageChangeProvider) {
            ((IPageChangeProvider) container).addPageChangedListener(new IPageChangedListener() {

                @Override
                public void pageChanged(PageChangedEvent event) {
                    if (isCurrentPage())
                        CSVImportWizardPage.this.updateControls(false);
                }
            });
        }

        validatePageComplete();
    }
    
    private void updateControls(boolean initial) {
        createIndexMappingGroup();
        updateCombos();
        if (!initial)
            composite.layout(true, true);
    }
    
    private void createIndexMappingGroup() {
        if (indexMappingGroup != null)
            indexMappingGroup.dispose();
        
        indexMappingGroup = new Group(composite, SWT.NONE);
        indexMappingGroup.setText("Column index mapping");
        GridDataFactory.fillDefaults().grab(true, false).span(2, 1).applyTo(indexMappingGroup);
        
        if (model.isVertexImport())
            createVertexIndexMappingField(indexMappingGroup);
        else
            createEdgeIndexMappingField(indexMappingGroup);
        
        createCommonIndexMappingField(indexMappingGroup);
    }

    private void createCommonIndexMappingField(Group parent) {
        
        componentMappingSelector = new DynamicComboFieldEditor("componentMapping", "Apros component mapping", parent);
        componentMappingSelector.addComboListener(new SelectionListener() {

            @Override
            public void widgetSelected(SelectionEvent e) {
                widgetDefaultSelected(e);
            }

            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
                model.setComponentMappingIndex(Integer.parseInt(componentMappingSelector.getValue()));
                validatePageComplete();
            }
        });
        
    }

    private void createVertexIndexMappingField(Group parent) {
        xCoordSelector = new DynamicComboFieldEditor("xCoord", "X Coordinate", parent);
        xCoordSelector.addComboListener(new SelectionListener() {

            @Override
            public void widgetSelected(SelectionEvent e) {
                widgetDefaultSelected(e);
            }

            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
                model.setXCoordIndex(Integer.parseInt(xCoordSelector.getValue()));
                validatePageComplete();
            }
        });

        yCoordSelector = new DynamicComboFieldEditor("yCoord", "Y Coordinate", parent);
        yCoordSelector.addComboListener(new SelectionListener() {

            @Override
            public void widgetSelected(SelectionEvent e) {
                widgetDefaultSelected(e);
            }

            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
                model.setYCoordIndex(Integer.parseInt(yCoordSelector.getValue()));
                validatePageComplete();
            }
        });
        zValueSelector = new DynamicComboFieldEditor("zValue", "Z Value", parent);
        zValueSelector.addComboListener(new SelectionListener() {

            @Override
            public void widgetSelected(SelectionEvent e) {
                widgetDefaultSelected(e);
            }

            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
                model.setZCoordIndex(Integer.parseInt(zValueSelector.getValue()));
                validatePageComplete();
            }
        });
        tempValueSelector = new DynamicComboFieldEditor("tempValue", "Temperature value", parent);
        tempValueSelector.addComboListener(new SelectionListener() {

            @Override
            public void widgetSelected(SelectionEvent e) {
                widgetDefaultSelected(e);
            }

            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
                model.setTempIndex(Integer.parseInt(tempValueSelector.getValue()));
                validatePageComplete();
            }
        });
        pressureValueSelector = new DynamicComboFieldEditor("pressureValue", "Pressure value", parent);
        pressureValueSelector.addComboListener(new SelectionListener() {

            @Override
            public void widgetSelected(SelectionEvent e) {
                widgetDefaultSelected(e);
            }

            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
                model.setPressureIndex(Integer.parseInt(pressureValueSelector.getValue()));
                validatePageComplete();
            }
        });
    }

    private void createEdgeIndexMappingField(Group parent) {
        startXCoordSelector = new DynamicComboFieldEditor("startxCoord", "Start X Coordinate", parent);
        startXCoordSelector.addComboListener(new SelectionListener() {

            @Override
            public void widgetSelected(SelectionEvent e) {
                widgetDefaultSelected(e);
            }

            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
                model.setStartXCoordIndex(Integer.parseInt(startXCoordSelector.getValue()));
                validatePageComplete();
            }
        });

        startYCoordSelector = new DynamicComboFieldEditor("startyCoord", "Start Y Coordinate", parent);
        startYCoordSelector.addComboListener(new SelectionListener() {

            @Override
            public void widgetSelected(SelectionEvent e) {
                widgetDefaultSelected(e);
            }

            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
                model.setStartYCoordIndex(Integer.parseInt(startYCoordSelector.getValue()));
                validatePageComplete();
            }
        });
        startZValueSelector = new DynamicComboFieldEditor("startzValue", "Start Z Value", parent);
        startZValueSelector.addComboListener(new SelectionListener() {

            @Override
            public void widgetSelected(SelectionEvent e) {
                widgetDefaultSelected(e);
            }

            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
                model.setStartZCoordIndex(Integer.parseInt(startZValueSelector.getValue()));
                validatePageComplete();
            }
        });
        
        endXCoordSelector = new DynamicComboFieldEditor("endxCoord", "End X Coordinate", parent);
        endXCoordSelector.addComboListener(new SelectionListener() {

            @Override
            public void widgetSelected(SelectionEvent e) {
                widgetDefaultSelected(e);
            }

            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
                model.setEndXCoordIndex(Integer.parseInt(endXCoordSelector.getValue()));
                validatePageComplete();
            }
        });

        endYCoordSelector = new DynamicComboFieldEditor("endyCoord", "End Y Coordinate", parent);
        endYCoordSelector.addComboListener(new SelectionListener() {

            @Override
            public void widgetSelected(SelectionEvent e) {
                widgetDefaultSelected(e);
            }

            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
                model.setEndYCoordIndex(Integer.parseInt(endYCoordSelector.getValue()));
                validatePageComplete();
            }
        });
        endZValueSelector = new DynamicComboFieldEditor("endzValue", "End Z Value", parent);
        endZValueSelector.addComboListener(new SelectionListener() {

            @Override
            public void widgetSelected(SelectionEvent e) {
                widgetDefaultSelected(e);
            }

            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
                model.setEndZCoordIndex(Integer.parseInt(endZValueSelector.getValue()));
                validatePageComplete();
            }
        });
        diameterSelector = new DynamicComboFieldEditor("diameterValue", "Diameter value", parent);
        diameterSelector.addComboListener(new SelectionListener() {

            @Override
            public void widgetSelected(SelectionEvent e) {
                widgetDefaultSelected(e);
            }

            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
                model.setDiameterIndex(Integer.parseInt(diameterSelector.getValue()));
                validatePageComplete();
            }
        });
        outerDiameterSelector = new DynamicComboFieldEditor("outerDiameterValue", "Outer Diameter value", parent);
        outerDiameterSelector.addComboListener(new SelectionListener() {

            @Override
            public void widgetSelected(SelectionEvent e) {
                widgetDefaultSelected(e);
            }

            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
                model.setOuterDiameterIndex(Integer.parseInt(outerDiameterSelector.getValue()));
                validatePageComplete();
            }
        });
        nominalMassFlowSelector = new DynamicComboFieldEditor("nominalMassFlowValue", "Nominal Mass Flow", parent);
        nominalMassFlowSelector.addComboListener(new SelectionListener() {

            @Override
            public void widgetSelected(SelectionEvent e) {
                widgetDefaultSelected(e);
            }

            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
                model.setNominalMassFlowIndex(Integer.parseInt(nominalMassFlowSelector.getValue()));
                validatePageComplete();
            }
        });
    }

    private void updateCombos() {
        String[][] namesAndValues = new String[headerIndexAndValues.size()][];

        int i = 0;
        for (Entry<Integer, String> entry : headerIndexAndValues.entrySet()) {
            int key = entry.getKey();
            String value = entry.getValue();

            String[] nameAndValue = new String[2];
            nameAndValue[0] = value;
            nameAndValue[1] = Integer.toString(key);
            namesAndValues[i++] = nameAndValue;
        }

        if (model.isVertexImport())
            updateVertexCombos(namesAndValues);
        else
            updateEdgeCombos(namesAndValues);

        componentMappingSelector.updateCombo(namesAndValues);
    }

    private void updateEdgeCombos(String[][] namesAndValues) {
        startXCoordSelector.updateCombo(namesAndValues);
        endXCoordSelector.updateCombo(namesAndValues);
        startYCoordSelector.updateCombo(namesAndValues);
        endYCoordSelector.updateCombo(namesAndValues);
        startZValueSelector.updateCombo(namesAndValues);
        endZValueSelector.updateCombo(namesAndValues);
        diameterSelector.updateCombo(namesAndValues);
        outerDiameterSelector.updateCombo(namesAndValues);
        nominalMassFlowSelector.updateCombo(namesAndValues);
    }

    private void updateVertexCombos(String[][] namesAndValues) {
        xCoordSelector.updateCombo(namesAndValues);
        yCoordSelector.updateCombo(namesAndValues);
        zValueSelector.updateCombo(namesAndValues);
        pressureValueSelector.updateCombo(namesAndValues);
        tempValueSelector.updateCombo(namesAndValues);
    }

    private void updateHeaders() {
        if (headerTable != null)
            headerTable.dispose();
        headerTable = new Table(tableComposite, SWT.NONE);
        headerTable.setHeaderVisible(true);
        headerTable.setLinesVisible(true);
        GridDataFactory.fillDefaults().grab(true, true).align(SWT.FILL, SWT.FILL).applyTo(tableComposite);
        for (int i = 0; i < headerTable.getColumns().length; i++) {
            TableColumn column = headerTable.getColumns()[i];
            column.dispose();
        }
        for (int i = 0; i < headerTable.getItemCount(); i++) {
            TableItem item = headerTable.getItem(i);
            item.dispose();
        }

        headerIndexAndValues.clear();

        try {
            List<CSVRecord> rows = model.getRows(5);

            for (int k = 0; k < rows.size(); k++) {
                CSVRecord row = rows.get(k);

                int columnCount = row.size();
                for (int i = 0; i < columnCount; i++) {
                    String value = row.get(i);
                    if (k == 0) {
                        TableColumn headerCol = new TableColumn(headerTable, SWT.NONE);
                        headerCol.setText(value);

                        tableColumnLayout.setColumnData(headerCol, new ColumnWeightData(10));
                        headerCol.pack();

                        headerIndexAndValues.put(i, value);
                    } else {
                        int actualK = k - 1;
                        TableItem item;
                        int itemCount = headerTable.getItemCount();
                        if (actualK >= itemCount) {
                            item = new TableItem(headerTable, SWT.NONE);
                        } else {
                            item = headerTable.getItem(actualK);
                        }
                        item.setText(i, value);
                    }
                }
            }

        } catch (IOException e) {
            setErrorMessage(e.getMessage());
        }
    }

    protected void validatePageComplete() {
        if (model.isVertexImport())
            setPageComplete(model.getXCoordIndex() != -1 && model.getYCoordIndex() != -1 && model.getComponentMappingIndex() != -1);
        else
            setPageComplete(model.getStartXCoordIndex() != 1 && model.getStartYCoordIndex() != -1 && model.getEndXCoordIndex() != -1 && model.getEndYCoordIndex() != -1 && model.getComponentMappingIndex() != -1);
    }

}