module TextViewport.Render.RenderState where

import Data.Hashable (Hashable)
import Data.Sequence (Seq)
import Data.Sequence qualified as Seq
import Data.Sequences (Index, Textual)
import TextViewport.Buffer.Buffer (Buffer(Buffer))
import TextViewport.Buffer.Buffer qualified as Buffer
import TextViewport.Buffer.Item
import TextViewport.Render.RenderBuffer (renderBuffer)
import TextViewport.Render.RenderCache (RenderCache(..), emptyRenderCacheFor, resizeCache)
import TextViewport.Render.RenderedBuffer (RenderedBuffer(RenderedBuffer))
import TextViewport.Render.RenderedBuffer qualified as RenderedBuffer

data RenderState a = RenderState
  { rsBuffer    :: Buffer a           -- original items
  , rsCache     :: RenderCache a      -- per-item cached renders
  , rsRendered  :: RenderedBuffer a   -- fully segmented + hyphenated lines
  , rsWidth     :: Int                -- segmenting width
  , rsLineCount :: Int                
  } deriving (Eq, Show)

mkRenderState :: (Hashable a, Textual a, Index a ~ Int) => Int -> Buffer a -> RenderState a
mkRenderState width buf =
  let (cache1, rendered) = renderBuffer width buf (emptyRenderCacheFor buf)
  in RenderState
       { rsBuffer    = buf
       , rsCache     = cache1
       , rsRendered  = rendered
       , rsWidth     = width
       , rsLineCount = length (RenderedBuffer.flatten rendered)
       }

-- RenderState has to be rebuilt whenever the buffer or the width changes.
updateRenderState :: (Hashable a, Textual a, Index a ~ Int) => Int -> Buffer a -> RenderState a -> RenderState a
updateRenderState width buf rs =
  let (cache1, rendered) = renderBuffer width buf (rsCache rs)
  in rs
      { rsBuffer    = buf
      , rsCache     = cache1
      , rsRendered  = rendered
      , rsWidth     = width
      , rsLineCount = length (RenderedBuffer.flatten rendered)
      }

modifyItemRS :: (Hashable a, Textual a, Index a ~ Int) => Int -> (Item a -> Item a) -> RenderState a -> RenderState a
modifyItemRS ix f st =
  let buf'    = Buffer.modifyItem ix f (rsBuffer st)
      cache'  = resizeCache buf' (rsCache st)
      (cache1, rendered1) = renderBuffer (rsWidth st) buf' cache'
  in st { rsBuffer    = buf'
        , rsCache     = cache1
        , rsRendered  = rendered1
        , rsLineCount = length (RenderedBuffer.flatten rendered1)
        }

insertItem :: (Hashable a, Textual a, Index a ~ Int) => Int -> Item a -> RenderState a -> RenderState a
insertItem i newItem st =
  let Buffer items = rsBuffer st
      items'       = Seq.insertAt i newItem items
      buf'         = Buffer items'
      cache'       = resizeCache buf' (rsCache st)
      (cache1, rendered1) = renderBuffer (rsWidth st) buf' cache'
  in st { rsBuffer = buf'
        , rsCache = cache1
        , rsRendered = rendered1
        , rsLineCount = length (RenderedBuffer.flatten rendered1)
        }

deleteItem :: (Hashable a, Textual a, Index a ~ Int) => Int -> RenderState a -> RenderState a
deleteItem i st =
  let Buffer items = rsBuffer st
      items'       = Seq.deleteAt i items
      buf'         = Buffer items'
      cache'       = resizeCache buf' (rsCache st)
      (cache1, rendered1) = renderBuffer (rsWidth st) buf' cache'
  in st { rsBuffer = buf'
        , rsCache = cache1
        , rsRendered = rendered1
        , rsLineCount = length (RenderedBuffer.flatten rendered1)
        }

replaceItem :: (Hashable a, Textual a, Index a ~ Int) => Int -> Item a -> RenderState a -> RenderState a
replaceItem i newItem st =
  let Buffer items = rsBuffer st
      items'       = Seq.update i newItem items
      buf'         = Buffer items'
      cache'       = resizeCache buf' (rsCache st)
      (cache1, rendered1) = renderBuffer (rsWidth st) buf' cache'
  in st { rsBuffer = buf'
        , rsCache = cache1
        , rsRendered = rendered1
        , rsLineCount = length (RenderedBuffer.flatten rendered1)
        }

appendItem :: (Hashable a, Textual a, Index a ~ Int) => Item a -> RenderState a -> RenderState a
appendItem newItem st =
  insertItem (Seq.length (let Buffer xs = rsBuffer st in xs)) newItem st

clearBuffer :: RenderState a -> RenderState a
clearBuffer st =
  let buf' = Buffer Seq.empty
      cache' = RenderCache Seq.empty
  in st { rsBuffer = buf'
        , rsCache = cache'
        , rsRendered = RenderedBuffer Seq.empty
        , rsLineCount = 0
        }

fromList :: (Hashable a, Textual a, Index a ~ Int) => Int -> [Item a] -> RenderState a
fromList width xs =
  let buf     = Buffer (Seq.fromList xs)
      cache0  = RenderCache (Seq.replicate (length xs) Nothing)
      (cache1, rendered) = renderBuffer width buf cache0
  in RenderState
       { rsBuffer    = buf
       , rsCache     = cache1
       , rsRendered  = rendered
       , rsWidth     = width
       , rsLineCount = length (RenderedBuffer.flatten rendered)
       }

fromSeq :: (Hashable a, Textual a, Index a ~ Int) => Int -> Seq (Item a) -> RenderState a
fromSeq width items =
  let buf     = Buffer items
      cache0  = RenderCache (Seq.replicate (Seq.length items) Nothing)
      (cache1, rendered) = renderBuffer width buf cache0
  in RenderState
       { rsBuffer    = buf
       , rsCache     = cache1
       , rsRendered  = rendered
       , rsWidth     = width
       , rsLineCount = length (RenderedBuffer.flatten rendered)
       }