package application.controller

import application.model.*
import javafx.collections.FXCollections
import javafx.collections.ObservableList
import javafx.fxml.FXML
import javafx.fxml.Initializable
import javafx.scene.control.ListCell
import javafx.scene.control.ListView
import org.charts.dataviewer.api.config.DataViewerConfiguration
import org.charts.dataviewer.api.data.PlotData
import org.charts.dataviewer.api.trace.ScatterTrace
import org.charts.dataviewer.javafx.JavaFxDataViewer
import org.charts.dataviewer.utils.TraceColour
import org.charts.dataviewer.utils.TraceVisibility
import java.net.URL
import java.util.*


class DataPanelController : Initializable, SelectedVesselListener {
    private var dataList: ObservableList<Pair<String, ArrayList<MessageData?>>> = FXCollections.observableArrayList()
    private lateinit var timeData: ArrayList<MessageData?>


    @FXML
    var dataListView = ListView<Pair<String, ArrayList<MessageData?>>>()

    @FXML
    var dataViewer = JavaFxDataViewer()


    override fun initialize(location: URL?, resources: ResourceBundle?) {
        setObservableSelectedVesselListener()
        dataListView.items = dataList


        val plotData = PlotData()
        val config = DataViewerConfiguration()
        config.showLegend(true)
        config.setLegendInsidePlot(false)

        dataListView.setCellFactory {
            object : ListCell<Pair<String, ArrayList<MessageData?>>?>() {
                override fun updateItem(item: Pair<String, ArrayList<MessageData?>>?, empty: Boolean) {
                    super.updateItem(item, empty)
                    text = if (empty) {
                        null
                    } else {
                        item?.first
                    }
                }
            }
        }

        dataListView.selectionModel.selectedItemProperty().addListener { _, _, newValue ->
            if (newValue == null) {
                plotData.allTraces.clear()
                config.setxAxisTitle("")
                config.setyAxisTitle("")
                dataViewer.updateConfiguration(config)

                dataViewer.resetPlot()

                return@addListener
            }

            val getValueVisitorX = GetValueVisitor()
            val getValueVisitorY = GetValueVisitor()

            val arrayListStringX = arrayListOf<String>()
            val arrayListDoubleX = arrayListOf<Double>()
            val arrayListStringY = arrayListOf<String>()
            val arrayListDoubleY = arrayListOf<Double>()

            for (x in 0 until newValue.second.size) {
                timeData[x]?.accept(getValueVisitorX)
                newValue.second[x]?.accept(getValueVisitorY)

                if (getValueVisitorY.value.toDoubleOrNull() == null) {
                    arrayListStringX.add(getValueVisitorX.value)
                    arrayListStringY.add(getValueVisitorY.value)
                } else {
                    arrayListStringX.add(getValueVisitorX.value)
                    arrayListDoubleY.add(getValueVisitorY.value.toDouble())
                }
            }

            val scatterTrace = ScatterTrace<Any>()
            scatterTrace.traceColour = TraceColour.RED
            scatterTrace.traceVisibility = TraceVisibility.TRUE

            val serieStringX: Array<String> = arrayListStringX.toTypedArray()
//            val serieDoubleX: Array<Double> = arrayListDoubleX.toTypedArray()
            val serieStringY: Array<String> = arrayListStringY.toTypedArray()
            val serieDoubleY: Array<Double> = arrayListDoubleY.toTypedArray()

            if (getValueVisitorY.value.toDoubleOrNull() == null) {
                scatterTrace.setxArray(serieStringX)
                scatterTrace.setyArray(serieStringY)
            } else {
                scatterTrace.setxArray(serieStringX)
                scatterTrace.setyArray(serieDoubleY)
            }

            config.plotTitle = ""
            config.setxAxisTitle("Date")
            config.setyAxisTitle(newValue.first)
            dataViewer.resetPlot()
            plotData.allTraces.clear()
            plotData.addTrace(scatterTrace)
            dataViewer.updateConfiguration(config)
            dataViewer.updatePlot(plotData)

        }

        plotData.allTraces.clear()
        config.setxAxisTitle("")
        config.setyAxisTitle("")
        config.plotTitle = ""
        dataViewer.updateConfiguration(config)
        dataViewer.updatePlot(plotData)

    }

    private fun setObservableSelectedVesselListener() {
        observableSelectedVessel.listeners.add(this)
    }

    private fun populateTime(vessel: Vessel): ArrayList<MessageData?> {
        val allTime: ArrayList<MessageData?> = vessel.getAllTime()
        allTime.sortBy { (it as Time).value }

        return allTime
    }

    private fun populateLatitude(vessel: Vessel): ArrayList<MessageData?> {
        val allLatitude: ArrayList<MessageData?> = vessel.getAllLatitude()
        allLatitude.sortBy { (it as Latitude).value }

        return allLatitude
    }

    private fun populateLongitude(vessel: Vessel): ArrayList<MessageData?> {
        val allLongitude: ArrayList<MessageData?> = vessel.getAllLongitude()
        allLongitude.sortBy { (it as Longitude).value }

        return allLongitude
    }

    private fun populateSpeedOverGround(vessel: Vessel): ArrayList<MessageData?> {
        val allSpeedOverGround: ArrayList<MessageData?> = vessel.getAllSpeedOverGround()
        allSpeedOverGround.sortBy { (it as SpeedOverGround).value }

        return allSpeedOverGround
    }

    private fun populateCourseOverGround(vessel: Vessel): ArrayList<MessageData?> {
        val allCourseOverGround: ArrayList<MessageData?> = vessel.getAllCourseOverGround()
        allCourseOverGround.sortBy { (it as CourseOverGround).value }

        return allCourseOverGround
    }

    private fun populateHeading(vessel: Vessel): ArrayList<MessageData?> {
        val allHeading: ArrayList<MessageData?> = vessel.getAllHeading()
        allHeading.sortBy { (it as Heading).value }

        return allHeading
    }

    private fun populateVesselName(vessel: Vessel): ArrayList<MessageData?> {
        val allVesselName: ArrayList<MessageData?> = vessel.getAllVesselName()
        allVesselName.sortBy { (it as VesselName).value }

        return allVesselName
    }

    private fun populateIMO(vessel: Vessel): ArrayList<MessageData?> {
        val allIMO: ArrayList<MessageData?> = vessel.getAllIMO()
        allIMO.sortBy { (it as IMO).value }

        return allIMO
    }

    private fun populateCallSign(vessel: Vessel): ArrayList<MessageData?> {
        val allCallSign: ArrayList<MessageData?> = vessel.getAllCallSign()
        allCallSign.sortBy { (it as CallSign).value }

        return allCallSign
    }

    private fun populateVesselType(vessel: Vessel): ArrayList<MessageData?> {
        val allVesselType: ArrayList<MessageData?> = vessel.getAllVesselType()
        allVesselType.sortBy { (it as VesselType).value }

        return allVesselType
    }

    private fun populateStatus(vessel: Vessel): ArrayList<MessageData?> {
        val allStatus: ArrayList<MessageData?> = vessel.getAllStatus()
        allStatus.sortBy { (it as Status).value }

        return allStatus
    }

    private fun populateLength(vessel: Vessel): ArrayList<MessageData?> {
        val allLength: ArrayList<MessageData?> = vessel.getAllLength()
        allLength.sortBy { (it as Length).value }

        return allLength
    }

    private fun populateWidth(vessel: Vessel): ArrayList<MessageData?> {
        val allWidth: ArrayList<MessageData?> = vessel.getAllWidth()
        allWidth.sortBy { (it as Width).value }

        return allWidth
    }

    private fun populateDraft(vessel: Vessel): ArrayList<MessageData?> {
        val allDraft: ArrayList<MessageData?> = vessel.getAllDraft()
        allDraft.sortBy { (it as Draft).value }

        return allDraft
    }

    private fun populateCargo(vessel: Vessel): ArrayList<MessageData?> {
        val allCargo: ArrayList<MessageData?> = vessel.getAllCargo()
        allCargo.sortBy { (it as Cargo).value }

        return allCargo
    }

    private fun populateDataList(vessel: Vessel) {
        val data = arrayListOf<Pair<String, ArrayList<MessageData?>>>()

        timeData = populateTime(vessel)

        data.add(Pair("Latitude", populateLatitude(vessel)))

        data.add(Pair("Longitude", populateLongitude(vessel)))

        data.add(Pair("Speed Over Ground", populateSpeedOverGround(vessel)))

        data.add(Pair("Course Over Ground", populateCourseOverGround(vessel)))

        data.add(Pair("Heading", populateHeading(vessel)))

        data.add(Pair("Vessel Name", populateVesselName(vessel)))

        data.add(Pair("IMO", populateIMO(vessel)))

        data.add(Pair("Call Sign", populateCallSign(vessel)))

        data.add(Pair("Vessel Type", populateVesselType(vessel)))

        data.add(Pair("Status", populateStatus(vessel)))

        data.add(Pair("Length", populateLength(vessel)))

        data.add(Pair("Width", populateWidth(vessel)))

        data.add(Pair("Draft", populateDraft(vessel)))

        data.add(Pair("Cargo", populateCargo(vessel)))

        dataList.addAll(data)
    }

    override fun onValueChanged(newValue: Vessel) {
        dataList.clear()
        populateDataList(newValue)

    }

}