package org.simantics.district.imports.ui;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

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.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.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;
import org.simantics.district.imports.ui.controls.DynamicComboFieldEditor;
import org.simantics.utils.ui.widgets.FileOrDirectorySelectionWidget;
import org.simantics.utils.ui.widgets.FileSelectionListener;
import org.simantics.utils.ui.widgets.FileSelectionWidget;

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 Group indexMappingGroup;

    private Composite composite;

    private Button isVertexImport;
    
    protected CSVImportWizardPage(CSVImportModel model) {
        super("Import CSV Data");
        this.model = model;
        setMessage("Select columng 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);

        delimiterCombo = new Combo(composite, SWT.DROP_DOWN | SWT.READ_ONLY);
        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) {

            }
        });

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

        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.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();
            }
        });
    }

    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();
            }
        });
    }

    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);
    }

    private void updateVertexcombos(String[][] namesAndValues) {
        xCoordSelector.updateCombo(namesAndValues);
        yCoordSelector.updateCombo(namesAndValues);
        zValueSelector.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);
    }

}