module Data.Text.ParagraphLayout.Internal.ResolvedSpan
    ( ResolvedSpan (..)
    , WithSpan (WithSpan)
    , splitBySpanIndex
    )
where

import Data.Text (Text)
import qualified Data.Text.ICU as BreakStatus (Line)

import Data.Text.ParagraphLayout.Internal.BiDiReorder
import Data.Text.ParagraphLayout.Internal.TextContainer
import Data.Text.ParagraphLayout.Internal.TextOptions

-- | Internal structure containing resolved values that may be shared with
-- other spans across the paragraph.
data ResolvedSpan d = ResolvedSpan
    { spanUserData :: d
    , spanIndex :: Int
    , spanOffsetInParagraph :: Int
    , spanText :: Text
    , spanTextOptions :: TextOptions
    , spanLineBreaks :: [(Int, BreakStatus.Line)]
    -- TODO: Can be optimised by starting with the shortest line break.
    , spanCharacterBreaks :: [(Int, ())]
    }

instance Eq (ResolvedSpan d) where
    a == b = spanIndex a == spanIndex b

instance TextContainer (ResolvedSpan d) where
    getText = spanText

-- | Wrapper for temporarily mapping the relationship to a `ResolvedSpan`.
data WithSpan d a = WithSpan (ResolvedSpan d) a

instance Functor (WithSpan d) where
    fmap f (WithSpan s a) = WithSpan s (f a)

instance TextContainer a => TextContainer (WithSpan d a) where
    getText (WithSpan _ c) = getText c

instance SeparableTextContainer a => SeparableTextContainer (WithSpan d a) where
    splitTextAt8 n (WithSpan rs c) = (WithSpan rs c1, WithSpan rs c2)
        where (c1, c2) = splitTextAt8 n c
    dropWhileStart p (WithSpan rs c) = WithSpan rs (dropWhileStart p c)
    dropWhileEnd p (WithSpan rs c) = WithSpan rs (dropWhileEnd p c)

instance WithLevel a => WithLevel (WithSpan d a) where
    level (WithSpan _ x) = level x

splitBySpanIndex :: [WithSpan d a] -> [[a]]
splitBySpanIndex xs = [getBySpanIndex i xs | i <- [0 ..]]

getBySpanIndex :: Int -> [WithSpan d a] -> [a]
getBySpanIndex idx xs = map contents $ filter matchingIndex $ xs
    where
        matchingIndex (WithSpan rs _) = (spanIndex rs) == idx
        contents (WithSpan _ x) = x