{- This Source Code Form is subject to the terms of the Mozilla Public License,
   v. 2.0. If a copy of the MPL was not distributed with this file, You can
   obtain one at https://mozilla.org/MPL/2.0/. -}

module SlackBuilder.Update
    ( checkUpdateAvailability
    , cloneFromGit
    , downloadWithTemplate
    , getAndLogLatest
    , handleExceptions
    , listRepository
    , repackageWithTemplate
    , reuploadWithTemplate
    , updatePackageIfRequired
    ) where

import Control.Exception (Exception(..), SomeException(..))
import Control.Monad.Catch (MonadCatch(..), catches, Handler(..))
import Control.Monad.IO.Class (MonadIO(..))
import Control.Monad.Trans.Reader (asks)
import Data.Foldable (Foldable(..), find)
import Data.HashMap.Strict (HashMap)
import qualified Data.HashMap.Strict as HashMap
import qualified Data.List.NonEmpty as NonEmpty
import Data.Maybe (fromJust, fromMaybe)
import Data.Text (Text)
import qualified Data.Text as Text
import qualified Data.Text.IO as Text.IO
import GHC.Records (HasField(..))
import qualified Network.HTTP.Req as Req
import Network.HTTP.Client (HttpException(..))
import System.FilePath
    ( (</>)
    , (<.>)
    , dropExtension
    , takeBaseName
    , splitFileName
    , takeDirectory
    , takeFileName
    , dropTrailingPathSeparator
    )
import System.Process
    ( CmdSpec(..)
    , CreateProcess(..)
    , StdStream(..)
    , withCreateProcess
    , waitForProcess
    )
import SlackBuilder.Config
import SlackBuilder.Download
import SlackBuilder.Info
import SlackBuilder.Package (PackageDescription(..), PackageUpdateData(..))
import qualified SlackBuilder.Package as Package
import SlackBuilder.Trans
import Text.URI (URI(..))
import qualified Text.URI as URI
import System.Directory
    ( listDirectory
    , doesDirectoryExist
    , withCurrentDirectory
    , removeDirectoryRecursive
    )
import System.Console.ANSI
    ( setSGR
    , SGR(..)
    , ColorIntensity(..)
    , Color(..)
    , ConsoleLayer(..)
    )
import Control.Monad (filterM, void)
import Data.List (isPrefixOf, isSuffixOf, partition)
import Data.Functor ((<&>))
import Data.Bifunctor (Bifunctor(..))

getAndLogLatest :: PackageDescription -> SlackBuilderT (Maybe PackageUpdateData)
getAndLogLatest description = do
    let PackageDescription{ latest = Package.Updater{ detectLatest }, name } = description
    liftIO (putStrLn $ Text.unpack name <> ": Retreiving the latest version.")
    detectedVersion <- detectLatest
    category <- HashMap.lookup name <$> listRepository
    pure $ PackageUpdateData description
        <$> category
        <*> detectedVersion

checkUpdateAvailability :: PackageUpdateData -> SlackBuilderT (Maybe PackageInfo)
checkUpdateAvailability PackageUpdateData{..} = do
    parsedInfoFile <- readInfoFile category $ getField @"name" description

    if version == getField @"version" parsedInfoFile
    then liftIO $ do
        setSGR [SetColor Foreground Dull Green]
        Text.IO.putStrLn
            $ getField @"name" description <> " is up to date (Version " <> version <> ")."
        setSGR [Reset]
        pure Nothing
    else liftIO $ do
        setSGR [SetColor Foreground Dull Yellow]
        Text.IO.putStr
            $ "A new version of "
            <> getField @"name" description
            <> " " <> getField @"version" parsedInfoFile
            <> " is available (" <> version <> ")."
        setSGR [Reset]
        putStrLn ""
        pure $ Just parsedInfoFile

updatePackageIfRequired :: PackageUpdateData -> SlackBuilderT ()
updatePackageIfRequired updateData
    = checkUpdateAvailability updateData
    >>= mapM_ (updatePackage updateData)

data DownloadUpdated = DownloadUpdated
    { result :: Package.Download
    , version :: Text
    , is64 :: Bool
    } deriving (Eq, Show)

updateDownload :: Text -> Package.Updater -> SlackBuilderT DownloadUpdated
updateDownload packagePath Package.Updater{..} = do
    latestDownloadVersion <- fromJust <$> detectLatest
    result <- getVersion packagePath latestDownloadVersion
    pure $ DownloadUpdated
        { result = result
        , version = latestDownloadVersion
        , is64 = is64
        }

cloneFromGit :: URI -> Text -> Text -> Text -> SlackBuilderT Package.Download
cloneFromGit repo tagPrefix packagePath version = do
    let downloadFileName = URI.unRText
            $ NonEmpty.last $ snd $ fromJust $ URI.uriPath repo
        relativeTarball = Text.unpack packagePath
            </> (dropExtension (Text.unpack downloadFileName) <> "-" <> Text.unpack version)
    (uri', checksum) <- cloneAndUpload (URI.render repo) relativeTarball tagPrefix
    pure $ Package.Download
        { md5sum = checksum
        , download = uri'
        }

repackageWithTemplate :: Maybe [String] -> Package.DownloadTemplate -> Text -> Text -> SlackBuilderT Package.Download
repackageWithTemplate Nothing template' = downloadWithTemplate template'
repackageWithTemplate (Just (cmd : arguments)) template' =
    reuploadWithTemplate' template' (RawCommand cmd arguments)
repackageWithTemplate (Just []) template' = reuploadWithTemplate template'

downloadWithTemplate :: Package.DownloadTemplate -> Text -> Text -> SlackBuilderT Package.Download
downloadWithTemplate downloadTemplate packagePath version = do
    repository' <- SlackBuilderT $ asks repository
    uri' <- liftIO $ Package.renderDownloadWithVersion downloadTemplate version
    checksum <- download uri' $ repository' </> Text.unpack packagePath
    pure $ Package.Download uri' $ snd checksum

reuploadWithTemplate :: Package.DownloadTemplate -> Text -> Text -> SlackBuilderT Package.Download
reuploadWithTemplate downloadTemplate packagePath version = do
    repository' <- SlackBuilderT $ asks repository
    uri' <- liftIO $ Package.renderDownloadWithVersion downloadTemplate version
    let packagePathRelativeToCurrent = repository' </> Text.unpack packagePath
    (downloadedFileName, checksum) <- download uri' packagePathRelativeToCurrent

    download' <- handleReupload packagePath
        $ packagePathRelativeToCurrent </> downloadedFileName
    pure $ Package.Download download' checksum

reuploadWithTemplate' :: Package.DownloadTemplate -> CmdSpec -> Text -> Text -> SlackBuilderT Package.Download
reuploadWithTemplate' downloadTemplate commands packagePath version = do
    repository' <- SlackBuilderT $ asks repository
    uri' <- liftIO $ Package.renderDownloadWithVersion downloadTemplate version
    let downloadFileName = Text.unpack
            $ URI.unRText
            $ NonEmpty.last $ snd $ fromJust $ URI.uriPath uri'
        packagePathRelativeToCurrent = repository' </> Text.unpack packagePath

    changedArchiveRootName <- extractRemote uri' packagePathRelativeToCurrent
    let relativeTarball = packagePathRelativeToCurrent
            </> fromMaybe downloadFileName changedArchiveRootName
    (relativeTarball', checksum) <- prepareSource relativeTarball

    download' <- handleReupload packagePath relativeTarball'
    pure $ Package.Download download' checksum
  where
    prepareSource tarballPath =
        liftIO (defaultCreateProcess tarballPath commands)
            >> liftIO (tarCompress tarballPath)
            <* liftIO (removeDirectoryRecursive tarballPath)
    tarCompress tarballPath =
        let archiveBaseFilename = takeFileName tarballPath
            appendTarExtension = (<.> "tar.xz")
         in fmap (appendTarExtension tarballPath,)
            $ withCurrentDirectory (takeDirectory tarballPath)
            $ createLzmaTarball archiveBaseFilename (appendTarExtension archiveBaseFilename)
    defaultCreateProcess cwd' cmdSpec
        = flip withCreateProcess (const . const . const waitForProcess)
        $ CreateProcess
            { use_process_jobs = False
            , std_out = Inherit
            , std_in = NoStream
            , std_err = Inherit
            , new_session = False
            , env = Nothing
            , detach_console = False
            , delegate_ctlc = False
            , cwd = Just cwd'
            , create_new_console = False
            , create_group = False
            , cmdspec = cmdSpec
            , close_fds = True
            , child_user = Nothing
            , child_group = Nothing
            }

handleReupload :: Text -> String -> SlackBuilderT URI
handleReupload packagePath relativeTarball = do
    liftIO $ putStrLn $ "Upload the source tarball " <> relativeTarball
    uploadSource relativeTarball category'

    hostedSources $ NonEmpty.cons category'
        $ pure $ Text.pack $ takeFileName relativeTarball
  where
    category' = Text.pack $ takeBaseName $ Text.unpack packagePath

updatePackage :: PackageUpdateData -> PackageInfo -> SlackBuilderT ()
updatePackage PackageUpdateData{..} info = do
    let packagePath = category <> "/" <> getField @"name" description
        latest' = getField @"latest" description

    repository' <- SlackBuilderT $ asks repository
    mainDownload <- (, getField @"is64" latest')
        <$> getField @"getVersion" latest' packagePath version
    moreDownloads <- traverse (updateDownload packagePath)
        $ getField @"downloaders" description
    let (downloads64, allDownloads) = partition snd
            $ mainDownload
            : (liftA2 (,) (getField @"result") (getField @"is64") <$> toList moreDownloads)
    let infoFilePath = repository' </> Text.unpack packagePath
            </> (Text.unpack (getField @"name" description) <.> "info")
        package' = info
            { version = version
            , downloads = getField @"download" . fst <$> allDownloads
            , checksums = getField @"md5sum" . fst <$> allDownloads
            , downloadX64 = getField @"download" . fst <$> downloads64
            , checksumX64 = getField @"md5sum" . fst <$> downloads64
            }
    liftIO $ Text.IO.writeFile infoFilePath $ generate package'
    updateSlackBuildVersion packagePath version
        $ getField @"version" <$> moreDownloads

    commit packagePath version

listRepository :: SlackBuilderT (HashMap Text Text)
listRepository = do
    repository' <- SlackBuilderT $ asks repository
    listing <- go repository' [] ""
    pure $ HashMap.fromList $ bimap Text.pack Text.pack <$> listing
  where
    go currentDirectory found accumulatedDirectory = do
        let fullDirectory = currentDirectory </> accumulatedDirectory
        contents <- liftIO $ listDirectory fullDirectory
        case find (isSuffixOf ".info") contents of
            Just _ ->
                let (category, packageName) = first dropTrailingPathSeparator
                        $ splitFileName accumulatedDirectory
                 in pure $ (packageName, category) : found
            Nothing ->
                let accumulatedDirectories = (accumulatedDirectory </>)
                        <$> filter (not . isPrefixOf ".") contents
                    directoryFilter = liftIO . doesDirectoryExist
                        . (currentDirectory </>)
                 in filterM directoryFilter accumulatedDirectories
                    >>= traverse (go currentDirectory found) <&> concat

handleExceptions :: (MonadIO m, MonadCatch m) => forall a. m a -> m ()
handleExceptions action = catches (void action)
    [ Handler handleHttp
    , Handler handleSome
    ]
  where
    printException e
        = liftIO (setSGR [SetColor Foreground Dull Red])
        >> liftIO (putStrLn e)
        >> liftIO (setSGR [Reset])
    handleHttp :: (MonadIO m, MonadCatch m) => Req.HttpException -> m ()
    handleHttp (Req.VanillaHttpException e)
        | HttpExceptionRequest _ exceptionContent <- e = printException
            $ show exceptionContent
        | InvalidUrlException url reason <- e = printException $ url <> ": " <> reason
    handleHttp (Req.JsonHttpException e) = printException e
    handleSome :: (MonadIO m, MonadCatch m) => SomeException -> m ()
    handleSome = printException . displayException