{-# OPTIONS_GHC -fno-warn-orphans #-}

module Issue
  ( Issue (..),
    Provenance (..),
    id,
    internalTags,
    replaceText,
  )
where

import CMark qualified as D
import CMark.Extra ()
import Comment qualified as G
import Comment.Language qualified as G
import Data.Binary (Binary (..))
import Data.ByteString.Lazy qualified as LB
import Data.Digest.Pure.SHA qualified as S
import Data.List.NonEmpty (NonEmpty)
import Data.List.NonEmpty qualified as N
import Data.Text qualified as T
import Data.Text.Encoding qualified as T
import Data.Text.IO qualified as T
import Data.Time.Clock (UTCTime (utctDay))
import GHC.Generics (Generic)
import GHC.Records (HasField (..))
import Git (Author (..), Commit (..))
import Git qualified as Git
import Issue.Parser qualified as I
import Issue.Provenance (Provenance (..))
import Issue.Tag (Tag (..))
import Issue.Text qualified as I
import Prelude hiding (id)

data Issue = Issue
  { commitHash :: Git.CommitHash,
    language :: G.Language,
    rawTextHash :: S.Digest S.SHA1State,
    title :: T.Text,
    file :: FilePath,
    provenance :: Provenance,
    startByte :: Int,
    endByte :: Int,
    startPoint :: G.Point,
    endPoint :: G.Point,
    tags :: [Tag],
    markers :: [T.Text],
    commentStyle :: G.CommentStyle,
    closed :: Bool
  }
  deriving (Show, Binary, Generic, Eq)

instance HasField "description" Issue (IO (Maybe (NonEmpty D.Node))) where
  getField issue = do
    rawText <- issue.rawText
    let node = D.commonmarkToNode [] rawText
    case I.parse I.issueMarkers node of
      Just parseResult -> pure (N.nonEmpty parseResult.paragraphs)
      Nothing -> pure Nothing

instance HasField "rawText" Issue (IO T.Text) where
  getField issue = do
    text <- getText issue
    let (_, rawText) = G.uncomment issue.language text
    pure rawText

instance HasField "comments" Issue (IO (Maybe (NonEmpty [D.Node]))) where
  getField issue = do
    rawText <- issue.rawText
    let node = D.commonmarkToNode [] rawText
    case I.parse I.issueMarkers node of
      Just parseResult -> pure (N.nonEmpty parseResult.comments)
      Nothing -> pure Nothing

id :: Issue -> T.Text
id issue = toSpinalCase issue.title
  where
    toSpinalCase = T.replace " " "-" . T.filter keep . T.toLower
    keep = (`elem` (concat [[' ', '-'], ['a' .. 'z'], ['0' .. '9']]))

internalTags :: Issue -> [Tag]
internalTags issue@(Issue {..}) =
  concat
    [ [ Tag "id" $ Just issue.id,
        Tag "createdAt" $ Just $ T.pack $ show $ utctDay provenance.first.date,
        Tag "modifiedAt" $ Just $ T.pack $ show $ utctDay provenance.last.date,
        Tag "author" $ Just provenance.first.author.name,
        Tag "editor" $ Just provenance.last.author.name,
        Tag "state" $ Just $ if closed then "closed" else "open"
      ],
      map (Tag "type" . Just) markers
    ]

instance HasField "internalTags" Issue [Tag] where
  getField issue = internalTags issue

instance HasField "id" Issue T.Text where
  getField issue = id issue

getText :: Issue -> IO T.Text
getText (Issue {..}) =
  T.decodeUtf8 . LB.toStrict . LB.take (fromIntegral (endByte - startByte)) . LB.drop (fromIntegral startByte)
    <$> Git.readTextFileOfBS commitHash file

replaceText :: Issue -> T.Text -> IO ()
replaceText issue s' =
  T.writeFile issue.file . replace (indent (comment s')) =<< T.readFile issue.file
  where
    comment = T.intercalate "\n" . map T.strip . T.lines . G.comment issue.commentStyle
    indent = T.intercalate "\n" . mapButFirst (T.replicate (issue.startPoint.column - 1) " " <>) . T.lines
    replace s t = before <> s <> after
      where
        t' = T.lines t
        before = T.intercalate "\n" (mapLast (T.take (issue.startPoint.column - 1)) (take issue.startPoint.row t'))
        after = T.unlines (mapFirst (T.drop issue.endPoint.column) (drop (issue.endPoint.row - 1) t'))
    mapFirst _ [] = []
    mapFirst f (x : xs) = f x : xs
    mapLast _ [] = []
    mapLast f [x] = [f x]
    mapLast f (x : xs) = x : mapLast f xs
    mapButFirst _ [] = []
    mapButFirst f (x : xs) = x : map f xs