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.chart.CategoryAxis
import javafx.scene.chart.NumberAxis
import javafx.scene.chart.ScatterChart
import javafx.scene.chart.XYChart.Data
import javafx.scene.chart.XYChart.Series
import javafx.scene.control.ListCell
import javafx.scene.control.ListView
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 xaxisNumber: CategoryAxis = CategoryAxis()

    @FXML
    var yaxisNumber: NumberAxis = NumberAxis()

    @FXML
    lateinit var scatterChartNumber: ScatterChart<String, Number>

    @FXML
    var xaxisCategory: CategoryAxis = CategoryAxis()

    @FXML
    var yaxisCategory: CategoryAxis = CategoryAxis()

    @FXML
    lateinit var scatterChartCategory: ScatterChart<String, String>

    override fun initialize(location: URL?, resources: ResourceBundle?) {
        xaxisNumber.animated = false
        yaxisNumber.animated = false
        xaxisCategory.animated = false
        yaxisCategory.animated = false
        setObservableSelectedVesselListener()
        dataListView.items = dataList



        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){
                scatterChartCategory.data.clear()
                scatterChartNumber.data.clear()
                return@addListener
            }
            val serieNumber = Series<String, Number>()
            val serieString = Series<String, String>()

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


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

                if (getValueVisitorY.value.toDoubleOrNull() == null){
                    serieString.data.add(Data<String, String>(getValueVisitorX.value, getValueVisitorY.value))
                } else{
                    serieNumber.data.add(Data<String, Number>(getValueVisitorX.value, getValueVisitorY.value.toDouble()))
                }

            }

            scatterChartNumber.data.clear()
            scatterChartCategory.data.clear()

            if (getValueVisitorY.value.toDoubleOrNull() == null){
                serieString.data.add(Data<String, String>(getValueVisitorX.value, getValueVisitorY.value))
                scatterChartCategory.data.addAll(serieString)
                setChartCategoryVisible()
                xaxisCategory.label = "Date"
                yaxisCategory.label = newValue.first
            } else{
                serieNumber.data.add(Data<String, Number>(getValueVisitorX.value, getValueVisitorY.value.toDouble()))
                scatterChartNumber.data.addAll(serieNumber)
                setChartNumberVisible()
                xaxisNumber.label = "Date"
                yaxisNumber.label = newValue.first
            }

        }

    }

    private fun setChartCategoryVisible(){
        scatterChartCategory.isVisible = true
        scatterChartNumber.isVisible = false
    }

    private fun setChartNumberVisible(){
        scatterChartCategory.isVisible = false
        scatterChartNumber.isVisible = true
    }

    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 populatVesselName(vessel: Vessel): ArrayList<MessageData?> {
        val allVesselName: ArrayList<MessageData?> = vessel.getAllVesselName()
        allVesselName.sortBy { (it as VesselName).value }

        return allVesselName
    }

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

        return allIMO
    }

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

        return allCallSign
    }

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

        return allVesselType
    }

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

        return allStatus
    }

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

        return allLength
    }

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

        return allWidth
    }

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

        return allDraft
    }

    private fun populatCargo(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", populatVesselName(vessel)))

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

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

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

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

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

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

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

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

        dataList.addAll(data)
    }

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

    }

}