package org.simantics.district.imports.ui;

import java.io.IOException;
import java.nio.file.Path;
import java.util.List;

import org.apache.commons.csv.CSVRecord;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.ui.IImportWizard;
import org.eclipse.ui.IWorkbench;
import org.geotools.geometry.DirectPosition2D;
import org.geotools.referencing.CRS;
import org.opengis.geometry.DirectPosition;
import org.opengis.geometry.MismatchedDimensionException;
import org.opengis.referencing.FactoryException;
import org.opengis.referencing.crs.CoordinateReferenceSystem;
import org.opengis.referencing.operation.MathTransform;
import org.opengis.referencing.operation.TransformException;
import org.simantics.Simantics;
import org.simantics.databoard.Bindings;
import org.simantics.db.Resource;
import org.simantics.db.WriteGraph;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.request.Write;
import org.simantics.district.imports.DistrictImportUtils;
import org.simantics.district.network.DistrictNetworkUtil;
import org.simantics.district.network.ontology.DistrictNetworkResource;
import org.simantics.district.network.ui.DNEdgeBuilder;

public class CSVImportWizard extends Wizard implements IImportWizard {

    private CSVImportModel model;
    
    public CSVImportWizard() {
        setWindowTitle("Import CSV data");
    }
    
    
    @Override
    public void init(IWorkbench workbench, IStructuredSelection selection) {
        model = new CSVImportModel();
        addPage(new CSVImportWizardFirstPage(model));
        addPage(new CSVImportWizardPage(model));
        addPage(new ComponentMappingPage(model));
    }
    
    @Override
    public boolean performFinish() {
        try {
            
            
            Path csvFile = model.getSource();
            char delim = model.getDelimiter();
            
            List<CSVRecord> rows = DistrictImportUtils.readRows(csvFile, delim, -1);
            
            Path wktFile = model.getWKTFile();
            
            int xCoordColumnIndex = model.getXCoordIndex();
            int yCoordColumnIndex = model.getYCoordIndex();
            int zCoordColumnIndex = model.getZCoordIndex();
            
            int startXCoordColumnIndex = model.getStartXCoordIndex();
            int startYCoordColumnIndex = model.getStartYCoordIndex();
            int startZValueColumnIndex = model.getStartZCoordIndex();
            int endXCoordColumnIndex = model.getEndXCoordIndex();
            int endYCoordColumnIndex = model.getEndYCoordIndex();
            int endZValueColumnIndex = model.getEndZCoordIndex();
            
            int mappingColumn = model.getComponentMappingIndex();
            
            try {
                CoordinateReferenceSystem sourceCRS = CRS.decode("EPSG:3879");
                CoordinateReferenceSystem targetCRS = CRS.decode("EPSG:4326");
                MathTransform transform = CRS.findMathTransform(sourceCRS, targetCRS, true);
                
                Simantics.getSession().syncRequest(new Write() {
                    
                    @Override
                    public void perform(WriteGraph graph) throws DatabaseException {
                        for (int k = 1; k < rows.size(); k++) {
                            CSVRecord row = rows.get(k);
                            
                            String mappingValue = row.get(mappingColumn);

                            try {
                                if (model.isVertexImport()) {
                                    String xCoords = row.get(xCoordColumnIndex);
                                    String yCoords = row.get(yCoordColumnIndex);
                                    double xCoord = Double.parseDouble(xCoords);
                                    double yCoord = Double.parseDouble(yCoords);
                                    
                                    String zs = row.get(zCoordColumnIndex);
                                    double z = Double.parseDouble(zs);
                                    
                                    DirectPosition2D targetPos = new DirectPosition2D();
                                    DirectPosition2D sourcePos = new DirectPosition2D(xCoord, yCoord);
                                    DirectPosition res = transform.transform(sourcePos, targetPos);
                                    double[] coords = res.getCoordinate();
                                    Resource vertex = DistrictNetworkUtil.createVertex(graph, model.getParentDiagram(), new double[] { coords[1], -coords[0]}, model.getComponentMappings().get(mappingValue));
                                    graph.claimLiteral(vertex, DistrictNetworkResource.getInstance(graph).Vertex_HasElevation, z, Bindings.DOUBLE);
                                } else {
                                    String startXCoords = row.get(startXCoordColumnIndex);
                                    String startYCoords = row.get(startYCoordColumnIndex);
                                    String endXCoords = row.get(endXCoordColumnIndex);
                                    String endYCoords = row.get(endYCoordColumnIndex);
                                    
                                    double startXCoord = Double.parseDouble(startXCoords);
                                    double startYCoord = Double.parseDouble(startYCoords);
                                    
                                    double endXCoord = Double.parseDouble(endXCoords);
                                    double endYCoord = Double.parseDouble(endYCoords);
                                    
                                    DirectPosition2D startTargetPos = new DirectPosition2D();
                                    DirectPosition2D startSourcePos = new DirectPosition2D(startXCoord, startYCoord);
                                    DirectPosition startRes = transform.transform(startSourcePos, startTargetPos);
                                    double[] startCoords = startRes.getCoordinate();
                                    
                                    DirectPosition2D endTargetPos = new DirectPosition2D();
                                    DirectPosition2D endSourcePos = new DirectPosition2D(endXCoord, endYCoord);
                                    DirectPosition endRes = transform.transform(endSourcePos, endTargetPos);
                                    double[] endCoords = endRes.getCoordinate();
                                    
                                    Resource edge = DNEdgeBuilder.create(graph, model.getParentDiagram(), new double[] { startCoords[1], -startCoords[0]}, new double[] { endCoords[1], -endCoords[0]}, 0.0000001);
                                    graph.claim(edge, DistrictNetworkResource.getInstance(graph).HasMapping, model.getComponentMappings().get(mappingValue));
//                                    graph.claimLiteral(edge, DistrictNetworkResource.getInstance(graph).Edge_HasDiameter, value);
                                }
                            } catch (MismatchedDimensionException | TransformException | DatabaseException e) {
                                e.printStackTrace();
                            }
                            
                        }
                    }
                });
                return true;
            } catch (FactoryException | DatabaseException e) {
                e.printStackTrace();
            }
            
        } catch (IOException e) {
            e.printStackTrace();
        }
        return false;
    }

}