package nova.monadic_sfx.implicits

import javafx.beans.property.ObjectProperty
import javafx.collections.ObservableList
import javafx.event.ActionEvent
import javafx.event.EventHandler
import javafx.scene.{input => jfxsi}
import javafx.{event => jfxe}
import monix.bio.Task
import monix.eval.Coeval
import monix.execution.Ack
import monix.execution.Cancelable
import monix.execution.Scheduler
import monix.execution.cancelables.SingleAssignCancelable
import monix.reactive.Observable
import monix.reactive.Observer
import monix.reactive.OverflowStrategy
import monix.tail.Iterant
import monix.{eval => me}
import org.gerweck.scalafx.util._
import scalafx.Includes._
import scalafx.beans.property.Property
import scalafx.beans.property.ReadOnlyProperty
import scalafx.collections.ObservableBuffer
import scalafx.event.subscriptions.Subscription
import scalafx.scene.Scene
import scalafx.scene.control.ButtonBase
import scalafx.scene.control.MenuItem

object JavaFXMonixObservables {

  implicit final class SceneObservables(private val scene: Scene)
      extends AnyVal {

    def observableMousePressed(): Observable[jfxsi.MouseEvent] = {
      import monix.execution.cancelables.SingleAssignCancelable
      Observable.create(OverflowStrategy.Unbounded) { sub =>
        val c = SingleAssignCancelable()
        val l = new jfxe.EventHandler[jfxsi.MouseEvent] {
          override def handle(event: jfxsi.MouseEvent): Unit = {
            if (sub.onNext(event) == Ack.Stop) c.cancel()
          }
        }

        scene.onMousePressed = l
        c := Cancelable(() =>
          scene.removeEventHandler(
            jfxsi.MouseEvent.MOUSE_PRESSED,
            l
          )
        )
        c
      }
    }

    def observableMouseDragged(): Observable[jfxsi.MouseEvent] = {
      import monix.execution.cancelables.SingleAssignCancelable
      Observable.create(OverflowStrategy.Unbounded) { sub =>
        val c = SingleAssignCancelable()
        val l = new jfxe.EventHandler[jfxsi.MouseEvent] {
          override def handle(event: jfxsi.MouseEvent): Unit = {
            if (sub.onNext(event) == Ack.Stop) c.cancel()
          }
        }

        scene.onMouseDragged = l
        c := Cancelable(() =>
          scene.removeEventHandler(
            jfxsi.MouseEvent.MOUSE_DRAGGED,
            l
          )
        )
        c
      }
    }
  }

  implicit final class BindObs[T, J](private val prop: Property[T, J])
      extends AnyVal {
    def -->(op: Observer[T]) = {
      op.onNext(prop.value)
    }

    def ==>(op: Property[T, J]) = {
      op <== prop
    }

    def <--(obs: Observable[T])(implicit s: Scheduler) = {
      obs.doOnNextF(v => Coeval(prop.value = v)).subscribe()
    }

    def asOption = prop.map(Option(_))

    def observableChange[J1 >: J]: Observable[J1] = {
      import monix.execution.cancelables.SingleAssignCancelable
      Observable.create(OverflowStrategy.Unbounded) { sub =>
        val c = SingleAssignCancelable()

        val canc =
          prop.onChange((a, b, c1) =>
            if (c1 != null && sub.onNext(c1) == Ack.Stop) c.cancel()
          )

        c := Cancelable(() => canc.cancel())
        c
      }
    }
  }

  implicit final class BindObs2[A](private val prop: ObjectProperty[A])
      extends AnyVal {

    def -->(sub: Observer[A]) =
      prop.onChange((a, b, c) => if (c != null) sub.onNext(c))

    def -->(op: Property[A, A]) = {
      prop.onChange((a, b, c) => if (c != null) op() = c)
    }

    def <--(obs: Observable[A])(implicit s: Scheduler) = {
      obs.doOnNextF(v => Coeval(prop() = v)).subscribe()
    }

    def observableChange[J1 >: A]: Observable[J1] = {
      import monix.execution.cancelables.SingleAssignCancelable
      Observable.create(OverflowStrategy.Unbounded) { sub =>
        val c = SingleAssignCancelable()

        val canc = prop.onChange((_, _, c1) =>
          if (c1 != null && sub.onNext(c1) == Ack.Stop) c.cancel()
        )

        c := Cancelable(() => canc.cancel())
        c
      }
    }
  }

  implicit final class ObservableListExt[A](
      private val buffer: ObservableList[A]
  ) extends AnyVal {

    // def -->(sub: Observer[A]) =
    //   buffer.onChange((a, b, c) => if (c != null) sub.onNext(c))

    // def -->(op: Property[A, A]) = {
    //   buffer.onChange((a, b, c) => if (c != null) op() = c)
    // }

    def <--(obs: Observable[A])(implicit s: Scheduler) = {
      obs
        .doOnNextF(v =>
          for {
            _ <- Coeval(buffer.clear())
            _ <- Coeval(buffer += v)
          } yield ()
        )
        .subscribe()
    }

    def observableChange[J1 >: A]: Observable[J1] = {
      import monix.execution.cancelables.SingleAssignCancelable
      Observable.create(OverflowStrategy.Unbounded) { sub =>
        val c = SingleAssignCancelable()

        implicit val s = sub.scheduler

        val canc =
          buffer.onChange((buf, _) =>
            loop(sub, buf.toIterable.iterator, c).runToFuture
          )

        c := Cancelable(() => canc.cancel())
        c
      }
    }

    private def loop(
        sub: Observer[A],
        it: Iterator[A],
        c: Cancelable
    ): Task[Unit] =
      if (it.hasNext) {
        val next = it.next()
        Task.deferFuture(sub.onNext(next)).flatMap {
          case Ack.Continue => loop(sub, it, c)
          case Ack.Stop     => Task(c.cancel())
        }
      } else Task.unit
  }

  implicit final class BindObs3[T, J](private val prop: ReadOnlyProperty[T, J])
      extends AnyVal {
    def -->(op: Observer[T]) = {
      op.onNext(prop.value)
    }

    def ==>(op: Property[T, J]) = {
      op <== prop
    }

    def observableChange[J1 >: J]: Observable[J1] = {
      import monix.execution.cancelables.SingleAssignCancelable
      Observable.create(OverflowStrategy.Unbounded) { sub =>
        val c = SingleAssignCancelable()

        val canc = prop.onChange((a, b, c1) =>
          if (c1 != null && sub.onNext(c1) == Ack.Stop) c.cancel()
        )

        c := Cancelable(() => canc.cancel())
        c
      }
    }
  }

  implicit final class ObjectPropertyObservableListExt[A](
      private val prop: ObjectProperty[ObservableList[A]]
  ) extends AnyVal {
    def <--(obs: Observable[Seq[A]])(implicit s: Scheduler) = {
      obs.doOnNext(v => me.Task(prop() = ObservableBuffer.from(v))).subscribe()
    }

    def -->(sub: Observer[A])(implicit s: Scheduler) = {
      val c = SingleAssignCancelable()
      val subs: Subscription = prop.onChange((a, b, c1) =>
        if (c1 != null)
          Iterant[Task]
            .fromIterable(c1.toIterable)
            .consume
            .use(consume(sub, c, _))
            .runToFuture
      )
      c := Cancelable(() => subs.cancel())
    }

    private def loop(sub: Observer[A], it: Iterator[A]): Task[Unit] =
      if (it.hasNext) {
        val next = it.next()
        Task.deferFuture(sub.onNext(next)).flatMap {
          case Ack.Continue => loop(sub, it)
          case Ack.Stop     => Task.unit
        }
      } else Task.unit

    private def consume(
        sub: Observer[A],
        c: Cancelable,
        consumer: Iterant.Consumer[Task, A]
    ): Task[Unit] =
      consumer.pull.flatMap {
        case Left(value) => Task.unit
        case Right(value) =>
          Task.deferFuture(sub.onNext(value)).flatMap {
            case Ack.Continue => consume(sub, c, consumer)
            case Ack.Stop     => Task(c.cancel())
          }
      }

  }

  implicit final class ObjectPropertyActionEvent(
      private val prop: ObjectProperty[EventHandler[ActionEvent]]
  ) extends AnyVal {
    // def <--(obs: Observable[ActionEvent])(implicit s: Scheduler) = {
    //   obs.doOnNext(v => me.Task(prop() = ObservableBuffer.from(v))).subscribe()
    // }

    // def -->(sub: Observer[ActionEvent]) =
    // prop().

  }

  // def emit(prop: ObjectProperty[EventHandler[ActionEvent]]) =

  implicit final class OnActionObservable(
      private val button: ButtonBase
  ) extends AnyVal {

    def observableAction: Observable[jfxe.ActionEvent] = {
      import monix.execution.cancelables.SingleAssignCancelable
      Observable.create(OverflowStrategy.Unbounded) { sub =>
        val c = SingleAssignCancelable()
        val l = new jfxe.EventHandler[jfxe.ActionEvent] {
          override def handle(event: jfxe.ActionEvent): Unit = {
            if (sub.onNext(event) == Ack.Stop) c.cancel()
          }
        }

        button.onAction = l
        c := Cancelable(() =>
          button.removeEventHandler(
            jfxe.ActionEvent.ACTION,
            l
          )
        )
        c
      }
    }
  }

  implicit final class MenuItemActionObservable(
      private val item: MenuItem
  ) extends AnyVal {

    def observableAction: Observable[jfxe.ActionEvent] = {
      import monix.execution.cancelables.SingleAssignCancelable
      Observable.create(OverflowStrategy.Unbounded) { sub =>
        val c = SingleAssignCancelable()
        val l = new jfxe.EventHandler[jfxe.ActionEvent] {
          override def handle(event: jfxe.ActionEvent): Unit = {
            if (sub.onNext(event) == Ack.Stop) c.cancel()
          }
        }

        item.onAction = l
        c := Cancelable(() =>
          item.removeEventHandler(
            jfxe.ActionEvent.ACTION,
            l
          )
        )
        c
      }
    }
  }
}