package outwatch.router

import org.scalajs.dom.window
import colibri.Observable
import outwatch.util.Store
import outwatch.util.Reducer
import cats.effect.Sync
import outwatch._
import outwatch.dsl._
import outwatch.router.dsl.Path
import outwatch.router.dsl.HashPath
import outwatch.router.dsl.Root

sealed trait Action
final case class Replace(path: Path) extends Action
final case class HistoryEvent(path: Path) extends Action

final case class RouterState[P](page: P)

/** An AppRouter handles parsing of URLs and mapping to pages of the given type.
  * @param siteRoot - The prefix part of a pathname, or the subpath at which your site is applied.
  *                 Usually this is just Root, but your site might need a prefix as in /my_site/[parsed pathname]
  * @param parent - The parent path at which this router is mounted. You can have routers contained in subroots of your site.
  * @param f - a mapping function from a Path to a page P.
  * @tparam F - the effect type
  * @tparam P - Your page type, such as a sealed trait root type.
  */
class AppRouter[F[_]: Sync, P](siteRoot: Path, parent: Path, f: Path => P) {
  // Sync from the required page to the window.location
  def routerReducer(state: RouterState[P], action: Action): RouterState[P] =
    action match {
      case Replace(path) =>
        println(s"Path = $path")
        window.history.pushState(
          "",
          "",
          HashPath(siteRoot, HashPath(parent, path)).toUrlString
        )
        state.copy(page = f(path))
      case HistoryEvent(path) =>
        println(s"Path = $path")
        state.copy(page = f(path))
      case _ => state
    }

  def store: F[RouterStore[P]] = {
    val startingPath = HashPath(window.location.hash.substring(1))

    Store.create[F, Action, RouterState[P]](
      Replace(startingPath),
      RouterState(f(startingPath)),
      Reducer(routerReducer _)
    )
  }

  def link(
      linkHref: String
  )(attrs: VDomModifier*)(implicit store: RouterStore[P]): BasicVNode =
    a(href := linkHref)(
      onClick.preventDefault.useLazy(
        Replace(HashPath(linkHref))
      ) --> store.sink,
      attrs
    )

  def render(resolver: RouterResolve[P])(implicit
      store: RouterStore[P]
  ): Observable[VDomModifier] =
    store.map { case (_, RouterState(p)) => resolver(p) }

  def watch()(implicit store: RouterStore[P]) =
    emitter(outwatch.dsl.events.window.onPopState).useLazy(
      HistoryEvent(HashPath(org.scalajs.dom.window.location.hash.substring(1)))
    ) --> store.sink

  // def link(
  //     p: P
  // )(attrs: VDomModifier*)(implicit store: RouterStore[P]): BasicVNode =
  //   a(href := p.toString())(
  //     onClick.preventDefault.useLazy(
  //       Replace(Path(p.toString()))
  //     ) --> store.sink,
  //     attrs
  //   )
}

object AppRouter {
  def render[P](resolver: RouterResolve[P])(implicit
      store: RouterStore[P]
  ): Observable[VDomModifier] =
    store.map { case (_, RouterState(p)) => resolver(p) }

  def watch[P]()(implicit store: RouterStore[P]) =
    emitter(
      outwatch.dsl.events.window.onPopState
      // .doOnNext(e =>
      //   println(
      //     s"changed ${org.scalajs.dom.window.location.toString()}"
      //   )
      // )
    ).useLazy(
      HistoryEvent(Path(org.scalajs.dom.window.location.pathname))
    ) --> store.sink

  def create[F[_]: Sync, P](notFound: P)(
      f: PartialFunction[Path, P]
  ): AppRouter[F, P] =
    create[F, P](Root, notFound)(f)

  def create[F[_]: Sync, P](parent: Path, notFound: P)(
      f: PartialFunction[Path, P]
  ): AppRouter[F, P] =
    new AppRouter[F, P](Root, parent, f.lift.andThen(_.getOrElse(notFound)))

  def createParseSiteRoot[F[_]: Sync, P](notFound: P)(
      f: PartialFunction[Path, P]
  ): AppRouter[F, P] =
    createParseSiteRoot[F, P](Root, notFound)(f)

  /** Automatically determine what siteroot we're using, based on the current URL and expected parent.
    * For example, your site could be deployed at /example/directory/, your router root path could be /names,
    * and the current url could be /example/directory/names/alice. So given the call:
    * createParseSubRoot[Page](Path("/names"), NotFound)(f), the router will work out that the window location
    * prefix must be /example/directory/names, and will handle actions such as Replace(Path("/names/bob"))
    * @param parent the parent for this router, another path perhaps managed by another router
    * @param notFound - the default case page assignment
    * @param f - a router function from Path to instances of your page type
    * @tparam P - your page type
    */
  def createParseSiteRoot[F[_]: Sync, P](parent: Path, notFound: P)(
      f: PartialFunction[Path, P]
  ): AppRouter[F, P] = {
    val initUrl = window.location.pathname
    // url is of form /sra/srb/src/pa/pb/pc...
    // so just drop the parent part from the right of the url if it exists.

    val siteRoot = initUrl.lastIndexOf(parent.toString) match {
      case x if x < 1 => Root
      case x          => Path(initUrl.substring(0, x))
    }

    val routerFun: Path => P = f.lift.andThen(_.getOrElse(notFound))
    new AppRouter[F, P](siteRoot, parent, routerFun)
  }
}