totalCopies,

import Data.Function (on)

import Data.List

import Data.Monoid (Sum (..))

import Refined
import Refined.Unsafe
import Category

import Util

type DiffSig a = a (DeckRep a) -> a (DeckRep a)

diff :: (HunkSYM repr, DeckSYM repr) => Map Text Card -> Map Text Card -> [repr (DeckRep repr) -> repr (DeckRep repr)]

totalCopies :: Card -> PositiveNumber
totalCopies card =
    PositiveNumber . unsafeRefine . getSum $
        mconcat . map (Sum . unrefine . runNumber . view copies) $
            card ^.. categories . traverse
diffCategory ::
    (DeckSYM repr, HunkSYM repr) =>
    Card
    -> [Category]
    -> [Category]
    -> [DiffSig repr]
diffCategory card left right = go mempty (sorter left) (sorter right)
  where
    sorter = sortBy (compare `on` view Category.name)
    go ::
        (HunkSYM repr, DeckSYM repr) =>
        [DiffSig repr]
        -> [Category]
        -> [Category]
        -> [DiffSig repr]
    go acc [] [] = acc
    go acc xs [] = acc ++ map (Diff.remove cardname . view Category.name) xs
    go acc [] ys = acc ++ map (uncurry (Diff.add cardname) . mkTuple) ys
    go acc lx@(x : xs) ly@(y : ys) =
        case (compare `on` view Category.name) x y of
            LT -> go (Diff.remove cardname (x ^. Category.name) : acc) xs ly
            EQ ->
                go
                    ( Diff.chunk cardname [Diff.deltaCopies (diffCopies x y) (x ^. Category.name)]
                        : acc
                    )
                    xs
                    ys
            GT -> go (Diff.add cardname (y ^. Category.name) (y ^. copies) : acc) lx ys
    mkTuple x = (x ^. Category.name, x ^. copies)
    diffCopies x y = uncurry (-) $ (y ^. copies, x ^. copies) & both %~ toNumber
    cardname = card ^. Deck.name
diff ::
    (HunkSYM repr, DeckSYM repr) => Map Text Card -> Map Text Card -> [DiffSig repr]

    go :: (HunkSYM repr, DeckSYM repr) => [repr (DeckRep repr) -> repr (DeckRep repr)] -> [Card] -> [Card] -> [repr (DeckRep repr) -> repr (DeckRep repr)]

    go acc xs [] = acc ++ map (\x -> Diff.delete (x ^. name)) xs

    go acc xs [] = acc ++ map (\x -> Diff.delete (x ^. Deck.name)) xs

        | x ^. name < y ^. name = go (Diff.delete (x ^. name) : acc) xs ly
        | x ^. name > y ^. name = go (Diff.insert y : acc) lx ys
        | otherwise = undefined -- Need a new algorithm here
            -- case (partialEqCard quantity x y, partialEqCard category x y) of
            --     (True, True) -> go acc xs ys
            --     (False, False) ->
            --         go
            --             ( chunk
            --                 (name x)
            --                 [modifyCopies (const $ quantity y), modifyCategory (const . category $ y)]
            --                 : acc
            --             )
            --             xs
            --             ys
            --     (False, _) -> go (chunk (name x) [modifyCopies (const $ quantity y)] : acc) xs ys
            --     (_, False) -> go (chunk (name x) [modifyCategory (const $ category y)] : acc) xs ys

        | x ^. Deck.name < y ^. Deck.name =
            go (Diff.delete (x ^. Deck.name) : acc) xs ly
        | x ^. Deck.name > y ^. Deck.name = go (Diff.insert y : acc) lx ys
        | x == y = go acc xs ys
        | otherwise =
            go (acc ++ categoryDiffs) xs ys
      where
        categoryDiffs =
            diffCategory
                x
                (Map.elems (x ^. categories))
                (Map.elems (y ^. categories))