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 javafx.scene.layout.StackPane
  import org.charts.dataviewer.api.config.DataViewerConfiguration
  import org.charts.dataviewer.api.data.PlotData
  import org.charts.dataviewer.api.trace.LineTrace
  import org.charts.dataviewer.api.trace.ScatterTrace
  import org.charts.dataviewer.javafx.JavaFxDataViewer
  import org.charts.dataviewer.utils.TraceColour
  import org.charts.dataviewer.utils.TraceMode
  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 stackPanePlot = StackPane()

  
      @FXML

      var dataViewer = JavaFxDataViewer()
  
  //    @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

          val plotData = PlotData()
          plotData.addTrace(createScatterTrace())
          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.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.setxAxisTitle("Date")
              config.setyAxisTitle(newValue.first)
              dataViewer.resetPlot()
              plotData.allTraces.clear()
              plotData.addTrace(scatterTrace)
              dataViewer.updateConfiguration(config)
              dataViewer.updatePlot(plotData)

          }

          plotData.allTraces.clear()
  //        plotData.addTrace(createScatterTrace())
          config.setxAxisTitle("")
          config.setyAxisTitle("")
          config.plotTitle = "No data selected"
          dataViewer.updateConfiguration(config)
          dataViewer.updatePlot(plotData)
  
  //        stackPanePlot.children.add(dataViewer)

      }

      private fun createScatterTrace(): ScatterTrace<*>? {
          val scatterTrace = ScatterTrace<Any>()
          scatterTrace.setxArray(arrayOf("asdf", "fdsa", "asdfffe", "asdfe", "asfee3"))
          scatterTrace.setyArray(arrayOf("pppp", "koojoi", "pp", "ii", "rty", "ert"))
          scatterTrace.traceName = "MyScatterTrace"
          scatterTrace.traceColour = TraceColour.PURPLE
          scatterTrace.traceMode = TraceMode.MARKERS
          return scatterTrace

      }

      fun createLineTrace(): LineTrace<*>? {
          val lineTrace = LineTrace<Any>()
          lineTrace.setxArray(arrayOf("asdf", "fdsa", "asdfffe", "asdfe", "asfee3"))
          lineTrace.setyArray(arrayOf(0.0, 1.0, 2.0, 3.0, 4.0, 5.0))
          lineTrace.traceName = "MyLineTrace"
          lineTrace.traceColour = TraceColour.PURPLE
          return lineTrace

      }

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