# SPDX-License-Identifier: AGPL-3.0-only
import asyncdispatch, strutils, sequtils, uri, options, times, json
import jester, karax/vdom

import router_utils
import ".."/[types, formatters, query, api]
import ../views/[general, profile, timeline, status, search, mastoapi]

export vdom
export uri, sequtils, json
export router_utils
export formatters, query, api
export profile, timeline, status, mastoapi

proc getQuery*(request: Request; tab, name: string): Query =
  case tab
  of "with_replies": getReplyQuery(name)
  of "media": getMediaQuery(name)
  #of "favorites": getFavoritesQuery(name)
  of "search": initQuery(params(request), name=name)
  else: Query(fromUser: @[name])

template skipIf[T](cond: bool; default; body: Future[T]): Future[T] =
  if cond:
    let fut = newFuture[T]()
    fut.complete(default)
    fut
  else:
    body

proc getUserId(username: string): Future[string] {.async.} =
  let user = await getGraphUser(username)
  if user.suspended:
    return "suspended"
  else:
    return user.id


proc getUsername*(userId: string): Future[string] {.async.} =
  let user = await getGraphUserById(userId)
  result = user.username


proc fetchProfile*(after: string; query: Query; cfg: Config; skipRail=false;
                   skipPinned=false): Future[Profile] {.async.} =
  let
    name = query.fromUser[0]
    userId = await getUserId(name)

  if userId.len == 0:
    return Profile(user: User(username: name))
  elif userId == "suspended":
    return Profile(user: User(username: name, suspended: true))

  # temporary fix to prevent errors from people browsing
  # timelines during/immediately after deployment
  var after = after
  if query.kind in {posts, replies} and after.startsWith("scroll"):
    after.setLen 0

  let
    rail =
      skipIf(skipRail or query.kind == media, @[]):
        getPhotoRail(name)

    user = getGraphUser(name)

  result =
    case query.kind
    of posts: await getGraphUserTweets(userId, TimelineKind.tweets, after)
    of replies: await getGraphUserTweets(userId, TimelineKind.replies, after)
    of media: await getGraphUserTweets(userId, TimelineKind.media, after)
    #of favorites: await getFavorites(userId, cfg, after)
    else: Profile(tweets: await getGraphTweetSearch(query, after))

  result.user = await user
  result.photoRail = await rail

  result.tweets.query = query

proc showTimeline*(request: Request; query: Query; cfg: Config; prefs: Prefs;
                   rss, after: string): Future[string] {.async.} =
  if query.fromUser.len != 1:
    let
      timeline = await getGraphTweetSearch(query, after)
      html = renderTweetSearch(timeline, prefs, getPath())
    return renderMain(html, request, cfg, prefs, "Multi", rss=rss)

  var profile = await fetchProfile(after, query, cfg, skipPinned=prefs.hidePins)
  template u: untyped = profile.user

  if u.suspended:
    return showError(getSuspended(u.username), cfg)

  if profile.user.id.len == 0: return

  let pHtml = renderProfile(profile, cfg, prefs, getPath())
  result = renderMain(pHtml, request, cfg, prefs, pageTitle(u), pageDesc(u),
                      rss=rss, images = @[u.getUserPic("_400x400")],
                      banner=u.banner)

template respTimeline*(timeline: typed) =
  let t = timeline
  if t.len == 0:
    resp Http404, showError("User \"" & @"name" & "\" not found", cfg)
  resp t

template respUserId*() =
  cond @"user_id".len > 0
  let username = await getUsername(@"user_id")
  if username.len > 0:
    redirect("/" & username)
  else:
    resp Http404, showError("User not found", cfg)

proc createTimelineRouter*(cfg: Config) =
  router timeline:
    get "/i/user/@user_id":
      respUserId()

    get "/intent/user":
      respUserId()

    get "/@name/?@tab?/?":
      cond '.' notin @"name"
      cond @"name" notin ["pic", "gif", "video", "search", "settings", "login", "intent", "i"]
      cond @"tab" in ["with_replies", "media", "search", "following", "followers", ""]
      let
        prefs = cookiePrefs()
        after = getCursor()
        names = getNames(@"name")
        tab = @"tab"

      case tab:
        of "followers":
          resp renderMain(renderUserList(await getGraphFollowers(await getUserId(@"name"), getCursor()), prefs), request, cfg, prefs)
        of "following":
          resp renderMain(renderUserList(await getGraphFollowing(await getUserId(@"name"), getCursor()), prefs), request, cfg, prefs)
        else:
          if request.headers.hasKey("Accept") and request.headers["Accept"] == "application/activity+json":
            let userId = await getUserId(@"name")

            if userId == "suspended" or userId.len == 0:
              resp Http404, {"Content-Type": "application/json"}, """{"error":"User not found"}"""

            let user = await getGraphUser(@"name")

            let userJson = getActivityStream(user, cfg, prefs)

            resp Http200, {"Content-Type": "application/json"}, $userJson

          var query = request.getQuery(@"tab", @"name")
          if names.len != 1:
            query.fromUser = names

          # used for the infinite scroll feature
          if @"scroll".len > 0:
            if query.fromUser.len != 1:
              var timeline = await getGraphTweetSearch(query, after)
              if timeline.content.len == 0: resp Http404
              timeline.beginning = true
              resp $renderTweetSearch(timeline, prefs, getPath())
            else:
              var profile = await fetchProfile(after, query, cfg, skipRail=true)
              if profile.tweets.content.len == 0: resp Http404
              profile.tweets.beginning = true
              resp $renderTimelineTweets(profile.tweets, prefs, getPath())

          let rss =
            if @"tab".len == 0:
              "/$1/rss" % @"name"
            elif @"tab" == "search":
              "/$1/search/rss?$2" % [@"name", genQueryUrl(query)]
            else:
              "/$1/$2/rss" % [@"name", @"tab"]

          respTimeline(await showTimeline(request, query, cfg, prefs, rss, after))