## Sync Personal Issue Tracker to Trello

import std/[algorithm, json, jsonutils, logging, options, sets, times, tables]
import cliutils, docopt, pit, uuids, zero_functional

import pit2trellopkg/[api, cliconstants]

from sequtils import toSeq

type
  CliConfig = ref object
    pit*: PitConfig
    apiBaseUrl*: string
    apiKey*: TrelloApiCredentials
    contexts*: seq[TrelloContext]

  TrelloContext = object
    context*: string
    boardId*: string

  SyncState = ref object
    pit*: PitConfig
    boards*: TableRef[string, TrelloBoard]
    contexts*: seq[TrelloContext]
    issues*: TableRef[IssueState, seq[Issue]]

func distribute[K, V](a: K, s: seq[V]): seq[(K, V)] =
  s --> map((a, it))

proc loadBoards(
    self: TrelloApiClient,
    contexts: seq[TrelloContext]
  ): TableRef[string, TrelloBoard] =

  let boards: seq[tuple[id: string, board: TrelloBoard]] = contexts -->
    map((it.boardId, self.loadBoard(it.boardId)))
  return newTable[string, TrelloBoard](boards)

proc loadCliConfig(args: Table[string, Value]): CliConfig =
  let pitCfg = loadConfig(args)

  let trelloJson = pitCfg.cfg.getJson("trello")
  let trelloCfg = CombinedConfig(docopt: args, json: trelloJson)

  result = CliConfig(
    apiBaseUrl: trelloCfg.getVal("api-base-url", "https://api.trello.com"),
    pit: pitCfg
  )

  fromJson(result.apiKey, trelloCfg.getJson("apiKey"))
  fromJson(result.contexts, trelloCfg.getJson("contexts"))

proc loadIssuesAndBoards(cfg: CliConfig, trello: TrelloApiClient): SyncState =
  SyncState(
    pit: cfg.pit,
    boards: trello.loadBoards(cfg.contexts),
    contexts: cfg.contexts,
    issues: cfg.pit.tasksDir.loadAllIssues)

proc listCategoryForIssueState(issState: IssueState): TrelloListCategory =
  return
    case issState:
    of Current, TodoToday, Pending: tlcInProgress
    of Dormant, Todo: tlcTodo
    of Done: tlcDone

proc issueStateForListCategory(listCategory: TrelloListCategory): IssueState =
  return
    case listCategory:
    of tlcTodo: Todo
    of tlcInProgress: TodoToday
    of tlcDone, tlcUnknown: Done

proc tagToTrelloLabel(trello: TrelloApiClient, board: TrelloBoard, tag: string): TrelloLabel =
  let foundLabel = board.labels --> find(it.name == tag)
  if foundLabel.isSome: return foundLabel.get
  else: return trello.createLabel(board, tag)

proc trelloLabelIdToTag(board: TrelloBoard, labelId: string): Option[string] =
  let foundLabel = board.labels --> find(it.id == labelId)
  if foundLabel.isSome: return some(foundLabel.get.name)
  else: return none[string]()

proc equiv(board: TrelloBoard, tc: TrelloCard, iss: Issue): bool =
  return
    tc.name == iss.summary and
    tc.desc == iss.details and
    sorted(iss.tags) == sorted(tc.labelIds -->
      map(board.trelloLabelIdToTag(it)).
      filter(it.isSome).
      map(it.get))

type TrelloListSummary = tuple[category: TrelloListCategory, id: string]

proc syncContext(
    trello: TrelloApiClient,
    s: SyncState,
    ctx: TrelloContext,
    dryRun = true) =
  if not s.boards.contains(ctx.boardId):
    raise newException(ValueError, "board not loaded for context\t" & $ctx)

  let board = s.boards[ctx.boardId]

  let issues = s.issues.find(
    propsFilter(newTable([("context", ctx.context)])))

  let cards: seq[tuple[list: TrelloListSummary, card: TrelloCard]] =
    board.lists.pairs.toSeq -->
      map(distribute(it[0], it[1])).flatten().
      map(distribute((category: it[0], id: it[1].id), it[1].cards)).flatten()

  ## We're going to do a bi-direction sync. First we will iterate through the
  ## issues and cards identifying matches.
  var unmatchedCardIds = toHashSet(cards --> map(it[1].id))
  var unmatchedIssueIds = toHashSet(issues --> map($it.id))
  var matched = newSeq[tuple[
    issue: Issue,
    card: TrelloCard,
    list: TrelloListSummary]]()

  ## 1. Look for issues that already have a `trello-card-id` property.
  for i in issues:
    if i.hasProp("trello-card-id"):
      let cardId = i["trello-card-id"]
      let foundCard = cards --> find(it.card.id == cardId)

      if foundCard.isNone:
        ## Ignore issues that are completed (may be archived in Trello)
        if i.state == Done: unmatchedIssueIds.excl($i.id)
        else:
          raise newException(Exception,
            "pit issue " & ($i.id)[0..6] & " references a Trello card with id " &
            cardId & " but that card is not any of the lists of the " &
            board.name & " board.")

      else:
        let c = foundCard.get
        matched.add((issue: i, card: c.card, list: c.list))
        unmatchedCardIds.excl(c.card.id)
        unmatchedIssueIds.excl($i.id)

  ## 2. Process updates to the matched cards
  for (lentIssue, lentCard, lentList) in matched:
    let (issue, card, list) = (lentIssue, lentCard, lentList)
    let pitListCategory = listCategoryForIssueState(issue.state)

    ## 2.a Ignore cards that have no differences (have the same contents and
    ## are in the same list category)
    if board.equiv(card, issue) and pitListCategory == list.category: continue

    if issue.hasProp("last-updated") and
       issue.getDateTime("last-updated") > card.lastUpdatedAt:

      # The PIT issue is newer
      let newCard = TrelloCard(
        id: card.id,
        desc: issue.details,
        name: issue.summary,
        labelIds: issue.tags --> map(trello.tagToTrelloLabel(board, it).id))

      if not dryRun:
        var targetListId: string
        if pitListCategory != list.category:
          targetListId =
            board.lists[listCategoryForIssueState(issue.state)][0].id
        else: targetListId = list.id
        trello.updateCard(newCard, targetListId)

      info "Trello updated: " & formatSectionIssue(issue, width = 64) &
        "  " & $list.category & " --> " & $pitListCategory

    else:
      # The Trello issue is newer
      issue.summary = card.name
      issue.details = card.desc
      issue.tags = card.labelIds -->
        map(board.trelloLabelIdToTag(it)).
        filter(it.isSome).
        map(it.get)

      if not dryRun:
        if pitListCategory != list.category:
          issue.changeState(s.pit.tasksDir, issueStateForListCategory(list.category))
        else: issue.store

      info "pit updated:    " & formatSectionIssue(issue, width = 64) &
        "  " & $pitListCategory & " --> " & $list.category

  let unmatchedCards = cards --> filter(unmatchedCardIds.contains(it.card.id))
  let unmatchedIssues = issues --> filter(unmatchedIssueIds.contains($it.id))

  for (list, lentCard) in unmatchedCards:
    let (list, card) = (list, lentCard)
    let issueState = issueStateForListCategory(list.category)

    # Don't worry about creating new issues for cards that are done.
    if issueState == Done: continue

    let issue = Issue(
      id: genUUID(),
      summary: card.name,
      details: card.desc,
      properties: newTable({
        "context": ctx.context,
        "trello-card-id": card.id
      }),
      tags: card.labelIds -->
        map(board.trelloLabelIdToTag(it)).
        filter(it.isSome).
        map(it.get))

    if not dryRun: s.pit.tasksDir.store(issue, issueState)
    info "pit created:    " & formatSectionIssue(issue, width = 64) & "  " &
      $issueState

  for lentIssue in unmatchedIssues:
    let issue = lentIssue

    # Don't worry about creating new cards for issues that are done.
    if issue.state == Done: continue

    let list = board.lists[listCategoryForIssueState(issue.state)][0]
    let newCard = TrelloCard(
      name: issue.summary,
      desc: issue.details,
      labelIds: issue.tags --> map(trello.tagToTrelloLabel(board, it).id))

    if not dryRun:
      let createdCard = trello.createCard(newCard, list)
      issue["trello-card-id"] = createdCard.id
      issue.store

    info "Trello created: " & formatSectionIssue(issue, width = 64) & "  " &
      list.name

when isMainModule:
 try:

  let consoleLogger = newConsoleLogger(
    levelThreshold = lvlInfo,
    fmtStr = "pit2trello - $levelname: ")
  logging.addHandler(consoleLogger)

  let args = docopt(USAGE, version = PIT2TRELLO_VERSION)

  if args["--debug"]:
    consoleLogger.levelThreshold = lvlDebug

  var cfg = loadCliConfig(args)

  if args["sync"]:
    let trello = initTrelloApiClient(cfg.apiKey, cfg.apiBaseUrl)
    let state = loadIssuesAndBoards(cfg, trello)

    for ctx in cfg.contexts: trello.syncContext(state, ctx, args["--dry-run"])

 except CatchableError:
  let ex = getCurrentException()
  fatal ex.msg
  debug ex.getStackTrace
  quit(QuitFailure)