data QCount a = QSingle a | QMultiple Int a
  deriving (Show, Eq)

qEncodeModified :: (Eq a) => [a] -> [QCount a]
qEncodeModified lst =
  map qModify (qPack lst)
  where
    qModify :: (Eq a) => [a] -> QCount a
    qModify p = case qLength p of
      1 -> QSingle (head p)
      len -> QMultiple len (head p)

qRunLengthDecode :: [QCount a] -> [a]
qRunLengthDecode clst = qReverse (qRunLengthDecodeI clst [])
  where
    qRunLengthDecodeI :: [QCount a] -> [a] -> [a]
    qRunLengthDecodeI [] acc = acc
    qRunLengthDecodeI (QSingle e : t) acc = qRunLengthDecodeI t (e : acc)
    qRunLengthDecodeI (QMultiple 0 _ : t) acc = qRunLengthDecodeI t acc
    qRunLengthDecodeI (QMultiple n e : t) acc = qRunLengthDecodeI (QMultiple (n - 1) e : t) (e : acc)

qRunLengthEncodeDirect :: (Eq a) => [a] -> [QCount a]
qRunLengthEncodeDirect [] = []
qRunLengthEncodeDirect (h : t) = qReverse (qRunLengthEncodeDirectI t (1, h) [])
  where
    qTupleToCount :: (Int, a) -> QCount a
    qTupleToCount (n, e) = case n of
      1 -> QSingle e
      _ -> QMultiple n e
    qRunLengthEncodeDirectI :: (Eq a) => [a] -> (Int, a) -> [QCount a] -> [QCount a]
    qRunLengthEncodeDirectI [] p acc = qTupleToCount p : acc
    qRunLengthEncodeDirectI (hI : tI) (n, e) acc
      | hI == e = qRunLengthEncodeDirectI tI (n + 1, e) acc
      | otherwise = qRunLengthEncodeDirectI tI (1, hI) (qTupleToCount (n, e) : acc)

qDuplicate :: [a] -> [a]
qDuplicate lst = qReverse (qDuplicateI lst [])
  where
    qDuplicateI :: [a] -> [a] -> [a]
    qDuplicateI [] acc = acc
    qDuplicateI (h : t) acc = qDuplicateI t (h : h : acc)

qReplicate :: [a] -> Int -> [a]
qReplicate lst n = qReverse (qReplicateI lst 0 [])
  where
    qReplicateI :: [a] -> Int -> [a] -> [a]
    qReplicateI [] _ acc = acc
    qReplicateI (h : t) k acc
      | n == k = qReplicateI t 0 acc
      | otherwise = qReplicateI (h : t) (k + 1) (h : acc)

qDropEveryNth :: [a] -> Int -> [a]
qDropEveryNth lst n = qReverse (qDropEveryNthI lst 1 [])
  where
    qDropEveryNthI :: [a] -> Int -> [a] -> [a]
    qDropEveryNthI [] _ acc = acc
    qDropEveryNthI (h : t) k acc
      | k == n = qDropEveryNthI t 1 acc
      | otherwise = qDropEveryNthI t (k + 1) (h : acc)

qSplitAt :: [a] -> Int -> ([a], [a])
qSplitAt lst n = qSplitAtI lst 0 []
  where
    qSplitAtI :: [a] -> Int -> [a] -> ([a], [a])
    qSplitAtI [] _ acc = (acc, [])
    qSplitAtI (h : t) k p
      | k == n = (qReverse p, h : t)
      | otherwise = qSplitAtI t (k + 1) (h : p)

qSlice :: [a] -> Int -> Int -> [a]
qSlice lst start end
  | start <= end = qReverse (qSliceI lst 1 [])
  | otherwise = []
  where
    qSliceI :: [a] -> Int -> [a] -> [a]
    qSliceI [] _ acc = acc
    qSliceI (h : t) k acc
      | k < start = qSliceI t (k + 1) acc
      | k <= end = qSliceI t (k + 1) (h : acc)
      | otherwise = acc

qRotate :: [a] -> Int -> [a]
qRotate lst k
  | abs k > len = lst
  | otherwise = (\(a, b) -> b ++ a) (qSplitAt lst (mod k len))
  where
    len :: Int
    len = qLength lst

qRemoveAt :: [a] -> Int -> (Maybe a, [a])
qRemoveAt lst k = qRemoveAtI lst 1 []
  where
    qRemoveAtI :: [a] -> Int -> [a] -> (Maybe a, [a])
    qRemoveAtI [] _ acc = (Nothing, qReverse acc)
    qRemoveAtI (h : t) n acc
      | n == k = (Just h, qReverse acc ++ t)
      | otherwise = qRemoveAtI t (n + 1) (h : acc)

module Part02 (part02) where

import Qarks.Nnp
  ( QCount (..),
    qDropEveryNth,
    qDuplicate,
    qEncodeModified,
    qRemoveAt,
    qReplicate,
    qRotate,
    qRunLengthDecode,
    qRunLengthEncodeDirect,
    qSlice,
    qSplitAt,
  )
import Test.Hspec
  ( context,
    describe,
    it,
    shouldBe,
  )
import Test.Hspec.Runner (SpecWith)

part02 :: SpecWith ()
part02 = describe "Part02" $ do
  context "Qarks.Nnp.qEncodeModified" $ do
    it "\"aaaabccaadeeee\"" $ do
      qEncodeModified "aaaabccaadeeee"
        `shouldBe` [ QMultiple 4 'a',
                     QSingle 'b',
                     QMultiple 2 'c',
                     QMultiple 2 'a',
                     QSingle 'd',
                     QMultiple 4 'e'
                   ]
  context "Qarks.Nnp.qRunLengthDecode" $ do
    it "[ QMultiple 4 'a', QSingle 'b', QMultiple 2 'c', QMultiple 2 'a', QSingle 'd', QMultiple 4 'e']" $ do
      qRunLengthDecode
        [ QMultiple 4 'a',
          QSingle 'b',
          QMultiple 2 'c',
          QMultiple 2 'a',
          QSingle 'd',
          QMultiple 4 'e'
        ]
        `shouldBe` "aaaabccaadeeee"
  context "Qarks.Nnp.qRunLengthEncodeDirect" $ do
    it "\"aaaabccaadeeee\"" $ do
      qRunLengthEncodeDirect "aaaabccaadeeee"
        `shouldBe` [ QMultiple 4 'a',
                     QSingle 'b',
                     QMultiple 2 'c',
                     QMultiple 2 'a',
                     QSingle 'd',
                     QMultiple 4 'e'
                   ]
  context "Qarks.Nnp.qDuplicate" $ do
    it "[1, 2, 3]" $ do
      qDuplicate [1 :: Int, 2, 3] `shouldBe` [1, 1, 2, 2, 3, 3]
  context "Qarks.Nnp.qReplicate" $ do
    it "\"abc\"" $ do
      qReplicate "abc" 3 `shouldBe` "aaabbbccc"
  context "Qarks.Nnp.qDropEveryNth" $ do
    it "3 of ['a' .. 'k']" $ do
      qDropEveryNth ['a' .. 'k'] 3 `shouldBe` "abdeghjk"
  context "Qarks.Nnp.qSplitAt" $ do
    it "3 of ['a' .. 'k']" $ do
      qSplitAt ['a' .. 'k'] 3 `shouldBe` ("abc", "defghijk")
  context "Qarks.Nnp.qSlice" $ do
    it "['a' .. 'k'] from 3 to 7" $ do
      qSlice ['a' .. 'k'] 3 7 `shouldBe` "cdefg"
  context "Qarks.Nnp.qRotate" $ do
    it "['a' .. 'h'] at 3" $ do
      qRotate ['a' .. 'h'] 3 `shouldBe` "defghabc"
    it "['a' .. 'h'] at -2" $ do
      qRotate ['a' .. 'h'] (-2) `shouldBe` "ghabcdef"
  context "Qarks.Nnp.qRemoveAt" $ do
    it "['a' .. 'd'] at 2" $ do
      qRemoveAt ['a' .. 'd'] 2 `shouldBe` (Just 'b', "acd")