module History.Issues
  ( Issues (..),
  )
where

import Backend qualified
import Data.Binary (Binary)
import Data.Function (on)
import Data.Map qualified as M
import Data.Proxy (Proxy)
import Data.Text qualified as T
import GHC.Generics (Generic)
import History.Plan (Id, Planable, Proto, assume, propagate, protoOf)
import History.Scramble (Scramble (..), getIssuesOfFile)
import Issue qualified as I

data Issues = Issues
  { commitHash :: Backend.CommitHash,
    issues :: M.Map T.Text I.Issue
  }
  deriving (Show, Generic, Binary)

instance Planable Issues where
  type Id Issues = Backend.CommitHash
  type Proto Issues = Scramble
  protoOf :: Proxy Issues -> Backend.CommitHash -> IO Scramble
  protoOf _ commitHash = do
    filesChanged <- Backend.getChangedFilesOf commitHash
    issues <- concat <$> mapM (getIssuesOfFile commitHash) filesChanged
    pure $
      Scramble
        { issues =
            M.unions
              [ M.singleton issue.id issue | issue <- issues
              ],
          ..
        }

  assume :: Scramble -> Issues
  assume (Scramble {..}) = Issues {..}

  propagate :: [Id Issues] -> Issues -> Scramble -> Issues
  propagate _ topIssues bottomScramble =
    Issues
      { commitHash = topIssues.commitHash,
        issues =
          M.mergeWithKey
            ( \_ topIssue bottomIssue ->
                Just $
                  topIssue
                    { I.provenance =
                        I.Provenance
                          { first = bottomIssue.provenance.first,
                            last =
                              if ((/=) `on` (.rawTextHash)) topIssue bottomIssue
                                then topIssue.provenance.last
                                else bottomIssue.provenance.last
                          }
                    }
            )
            ( \topIssues -> topIssues
            )
            ( \bottomIssues ->
                M.map
                  ( \bottomIssue ->
                      bottomIssue {I.closed = True}
                  )
                  bottomIssues
            )
            topIssues.issues
            bottomScramble.issues
      }