module Data.Text.ParagraphLayout.Internal.ParagraphLine (cutLines, mergeLines)
where

import Data.Int (Int32)
import qualified Data.List.NonEmpty as NonEmpty

import Data.Text.ParagraphLayout.Internal.Fragment
import Data.Text.ParagraphLayout.Internal.LinePagination
import Data.Text.ParagraphLayout.Internal.ParagraphLayout
import Data.Text.ParagraphLayout.Internal.Rect

-- | Represents one line of a `ParagraphLayout`.
newtype ParagraphLine = ParagraphLine ParagraphLayout

instance Line ParagraphLine where
    lineHeight (ParagraphLine pl) = height $ paragraphRect pl

-- | Split the given `ParagraphLayout` into individual lines.
cutLines :: ParagraphLayout -> [ParagraphLine]
cutLines pl = map (\ y -> cutLine y pl) (lineOrigins pl)

-- | Reduce the given `ParagraphLayout` to fragments with the given `y_origin`.
--
-- This assumes that each line consists of fragments of equal height and that
-- there is no space between lines.
--
-- TODO: Use line numbers to support rich text.
cutLine :: Int32 -> ParagraphLayout -> ParagraphLine
cutLine y pl = ParagraphLine $ shiftFragments (-y) $ limitFragments y pl

lineOrigins :: ParagraphLayout -> [Int32]
lineOrigins pl = dedupe $ map (y_origin . fragmentRect) $ paragraphFragments pl

-- | Remove duplicates from a sorted list.
dedupe :: Eq a => [a] -> [a]
dedupe xs = map NonEmpty.head $ NonEmpty.group xs

-- | Combine the given `ParagraphLine`s into a `ParagraphLayout` by merging
-- their fragments.
mergeLines :: [ParagraphLine] -> ParagraphLayout
mergeLines lls = foldl mergeLine emptyParagraphLayout lls

mergeLine :: ParagraphLayout -> ParagraphLine -> ParagraphLayout
mergeLine pl (ParagraphLine nextLine) = pl'
    where
        -- Quadratic time complexity. TODO: Consider optimising.
        pl' = appendFragments pl $ shiftFragments y nextLine
        y = y_terminus $ paragraphRect pl

-- | Add @dy@ to each fragment's `y_origin`.
shiftFragments :: Int32 -> ParagraphLayout -> ParagraphLayout
shiftFragments dy = mapFragments (shiftFragment dy)

shiftFragment :: Int32 -> Fragment -> Fragment
shiftFragment dy f = f'
    where
        f' = f { fragmentRect = r' }
        r' = r { y_origin = y_origin r + dy }
        r = fragmentRect f

-- | Keep only fragments with the given `y_origin` value.
limitFragments :: Int32 -> ParagraphLayout -> ParagraphLayout
limitFragments y = filterFragments ((== y) . y_origin . fragmentRect)