{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE NoImplicitPrelude #-}

-- | Concurrent logging with multi-line output support
module Omni.Log.Concurrent
  ( LineManager,
    BuildState (..),
    withLineManager,
    initializeLines,
    updateLine,
    updateLineState,
  )
where

import Alpha
import Data.IORef (IORef, newIORef, readIORef, writeIORef)
import qualified Data.Map as Map
import qualified Data.Text as Text
import Omni.Log.Terminal (OutputMode (..), TerminalInfo (..), detectTerminal, truncateToWidth)
import Omni.Namespace (Namespace)
import qualified Omni.Namespace as Namespace
import Rainbow (chunk, fore, green, red, white)
import qualified Rainbow
import qualified System.Console.ANSI as ANSI
import qualified System.IO as IO
import System.IO.Unsafe (unsafePerformIO)

data BuildState = Analyzing | Pending | Building | Success | Failed
  deriving (Eq, Show)

data LineManager = LineManager
  { lmNamespaces :: [Namespace],
    lmTermInfo :: TerminalInfo
  }

{-# NOINLINE currentLineManager #-}
currentLineManager :: IORef (Maybe LineManager)
currentLineManager = unsafePerformIO (newIORef Nothing)

{-# NOINLINE namespaceLines #-}
namespaceLines :: IORef (Map Namespace Int)
namespaceLines = unsafePerformIO (newIORef Map.empty)

withLineManager :: [Namespace] -> (LineManager -> IO a) -> IO a
withLineManager nss action = do
  termInfo <- detectTerminal

  case tiMode termInfo of
    SingleLine -> do
      -- Single-line mode: no reservations, updates in place
      let mgr = LineManager {lmNamespaces = nss, lmTermInfo = termInfo}
      writeIORef currentLineManager (Just mgr)
      result <- action mgr
      IO.hPutStrLn IO.stderr "" -- Final newline
      writeIORef currentLineManager Nothing
      writeIORef namespaceLines Map.empty
      pure result
    MultiLine -> do
      -- Multi-line mode: reserve lines for each namespace
      let numLines = min (length nss) (tiHeight termInfo - 2)
      IO.hPutStrLn IO.stderr ""
      replicateM_ numLines (IO.hPutStrLn IO.stderr "")
      ANSI.hCursorUp IO.stderr numLines

      let mgr = LineManager {lmNamespaces = nss, lmTermInfo = termInfo}
      writeIORef currentLineManager (Just mgr)

      -- Initialize the namespace -> line mapping
      writeIORef namespaceLines (Map.fromList <| zip nss [0 ..])

      result <- action mgr

      IO.hPutStrLn IO.stderr ""
      writeIORef currentLineManager Nothing
      writeIORef namespaceLines Map.empty
      pure result

-- | Initialize all lines with pending status
initializeLines :: LineManager -> IO ()
initializeLines LineManager {..} =
  case tiMode lmTermInfo of
    SingleLine -> pure () -- No initialization needed
    MultiLine -> do
      nsMap <- readIORef namespaceLines
      forM_ (Map.toList nsMap) <| \(ns, _) -> do
        ANSI.hSetCursorColumn IO.stderr 0
        ANSI.hClearLine IO.stderr
        let nsText = Text.pack (Namespace.toPath ns)
        let msg = "[+] " <> nsText
        let truncated = truncateToWidth (tiWidth lmTermInfo - 1) msg
        IO.hPutStrLn IO.stderr (Text.unpack truncated)
        IO.hFlush IO.stderr

updateLine :: Namespace -> Text -> IO ()
updateLine ns output = do
  mMgr <- readIORef currentLineManager
  case mMgr of
    Nothing -> do
      IO.hPutStr IO.stderr (Text.unpack <| output <> "\r")
      IO.hFlush IO.stderr
    Just LineManager {..} ->
      case tiMode lmTermInfo of
        SingleLine -> do
          -- Single line: update in place
          let nsText = Text.pack (Namespace.toPath ns)
          let msg =
                if Text.null output
                  then "[~] " <> nsText
                  else "[~] " <> nsText <> ": " <> output
          let truncated = truncateToWidth (tiWidth lmTermInfo - 1) msg
          -- Clear line and write
          IO.hPutStr IO.stderr "\r"
          IO.hPutStr IO.stderr (Text.unpack truncated)
          -- Pad to clear previous longer text
          let padding = replicate (tiWidth lmTermInfo - Text.length truncated - 1) ' '
          IO.hPutStr IO.stderr padding
          IO.hPutStr IO.stderr "\r"
          IO.hPutStr IO.stderr (Text.unpack truncated)
          IO.hFlush IO.stderr
        MultiLine -> do
          -- Multi-line: use reserved lines with truncation
          nsMap <- readIORef namespaceLines
          case Map.lookup ns nsMap of
            Nothing -> pure ()
            Just lineNum -> do
              let numLines = length lmNamespaces
              -- Move to the target line from bottom
              ANSI.hCursorUp IO.stderr (numLines - lineNum)
              ANSI.hSetCursorColumn IO.stderr 0
              ANSI.hClearLine IO.stderr
              let nsText = Text.pack (Namespace.toPath ns)
              let msg =
                    if Text.null output
                      then "[~] " <> nsText
                      else "[~] " <> nsText <> ": " <> output
              let truncated = truncateToWidth (tiWidth lmTermInfo - 1) msg
              IO.hPutStr IO.stderr (Text.unpack truncated)
              IO.hFlush IO.stderr
              -- Move back to bottom
              ANSI.hCursorDown IO.stderr (numLines - lineNum)

updateLineState :: Namespace -> BuildState -> IO ()
updateLineState ns buildState = do
  mMgr <- readIORef currentLineManager
  case mMgr of
    Nothing -> pure ()
    Just LineManager {..} ->
      case tiMode lmTermInfo of
        SingleLine -> do
          -- Single line: show completion, keep visible for success/failure
          let nsText = Text.pack (Namespace.toPath ns)
          let (symbol, color) = case buildState of
                Success -> ("✓", green)
                Failed -> ("x", red)
                _ -> ("~", white)
          let msg = "[" <> symbol <> "] " <> nsText
          let truncated = truncateToWidth (tiWidth lmTermInfo - 1) msg

          IO.hPutStr IO.stderr "\r"
          Rainbow.hPutChunks IO.stderr [fore color <| chunk truncated]
          case buildState of
            Success -> IO.hPutStrLn IO.stderr "" -- Keep successes visible
            Failed -> IO.hPutStrLn IO.stderr "" -- Keep failures visible
            _ -> pure () -- Transient states overwrite
          IO.hFlush IO.stderr
        MultiLine -> do
          -- Multi-line: use reserved lines with truncation
          nsMap <- readIORef namespaceLines
          case Map.lookup ns nsMap of
            Nothing -> pure ()
            Just lineNum -> do
              let numLines = length lmNamespaces
              ANSI.hCursorUp IO.stderr (numLines - lineNum)
              ANSI.hSetCursorColumn IO.stderr 0
              ANSI.hClearLine IO.stderr
              let nsText = Text.pack (Namespace.toPath ns)
              let (symbol, colorFn) = case buildState of
                    Success -> ("✓", fore green)
                    Failed -> ("x", fore red)
                    Analyzing -> ("+", identity)
                    Pending -> ("…", identity)
                    Building -> ("~", identity)
              let msg = "[" <> symbol <> "] " <> nsText
              let truncated = truncateToWidth (tiWidth lmTermInfo - 1) msg
              Rainbow.hPutChunks IO.stderr [colorFn <| chunk truncated]
              IO.hFlush IO.stderr
              ANSI.hCursorDown IO.stderr (numLines - lineNum)