-- | Functions for pretty-printing games to the console.
module Hs2048.Renderer
    ( center
    , color
    , renderBoard
    , renderGame
    , renderTile
    ) where

import           Data.Monoid  ((<>))
import qualified Hs2048.Board as B
import qualified Hs2048.Tile  as T

{- |
    Centers a string in the given number of characters, using spaces for
    padding.

    >>> center 3 "x"
    " x "
    >>> center 2 "x"
    " x"
-}
center :: Int -> String -> String
center :: Int -> String -> String
center Int
w String
s = String
prefix String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
s String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
suffix
  where
    prefix :: String
prefix = Int -> Char -> String
forall a. Int -> a -> [a]
replicate (Float -> Int
forall b. Integral b => Float -> b
forall a b. (RealFrac a, Integral b) => a -> b
ceiling Float
n) Char
' '
    suffix :: String
suffix = Int -> Char -> String
forall a. Int -> a -> [a]
replicate (Float -> Int
forall b. Integral b => Float -> b
forall a b. (RealFrac a, Integral b) => a -> b
floor Float
n) Char
' '
    n :: Float
n = Int -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int
w Int -> Int -> Int
forall a. Num a => a -> a -> a
- String -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length String
s) Float -> Float -> Float
forall a. Fractional a => a -> a -> a
/ (Float
2 :: Float)

{- |
    Calculates the color code for a tile. See
    <http://en.wikipedia.org/wiki/ANSI_escape_code#Colors>.

    >>> color Nothing
    30
    >>> color (Just 2)
    31
    >>> color (Just 2048)
    45
-}
color :: T.Tile -> Int
color :: Tile -> Int
color Tile
t = Int
30 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
x
  where
    x :: Int
x = if Int
r Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
6 then Int
r Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4 else Int
r
    r :: Int
r = Tile -> Int
T.rank Tile
t

{- |
    Renders a board with colorized, centered tiles. See 'renderTile' and
    'center'.

    >>> renderBoard [[Nothing, Just 2]]
    "\ESC[30m-\ESC[0m \ESC[31m2\ESC[0m\n"
    >>> renderBoard [[Nothing, Just 16]]
    " \ESC[30m-\ESC[0m \ESC[34m16\ESC[0m\n"
-}
renderBoard :: B.Board -> String
renderBoard :: Board -> String
renderBoard Board
b = [String] -> String
unlines (([String] -> String) -> [[String]] -> [String]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [String] -> String
unwords [[String]]
vs')
  where
    vs' :: [[String]]
vs' = ([String] -> [String]) -> [[String]] -> [[String]]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((String -> String) -> [String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int -> String -> String
center Int
l)) [[String]]
vs
    vs :: [[String]]
vs = ([Tile] -> [String]) -> Board -> [[String]]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Tile -> String) -> [Tile] -> [String]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Tile -> String
renderTile) Board
b
    l :: Int
l = [Int] -> Int
forall a. Ord a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum [Int]
ls
    ls :: [Int]
ls = [[String]]
vs [[String]] -> ([String] -> [Int]) -> [Int]
forall a b. [a] -> (a -> [b]) -> [b]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (String -> Int) -> [String] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap String -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length

{- |
    Renders a board along with its score. See 'renderBoard'.

    >>> renderGame [[Nothing, Just 2]]
    "Score: 0\n\ESC[30m-\ESC[0m \ESC[31m2\ESC[0m\n"
-}
renderGame :: B.Board -> String
renderGame :: Board -> String
renderGame Board
b = [String] -> String
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat
    [ String
"Score: "
    , Int -> String
forall a. Show a => a -> String
show (Board -> Int
B.score Board
b)
    , String
"\n"
    , Board -> String
renderBoard Board
b
    ]

{- |
    Renders a colorized tile. See 'color'.

    >>> renderTile Nothing
    "\ESC[30m-\ESC[0m"
    >>> renderTile (Just 2)
    "\ESC[31m2\ESC[0m"
-}
renderTile :: T.Tile -> String
renderTile :: Tile -> String
renderTile Tile
t = [String] -> String
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat
    [ String
"\ESC["
    , Int -> String
forall a. Show a => a -> String
show (Tile -> Int
color Tile
t)
    , String
"m"
    , Tile -> String
T.render Tile
t
    , String
"\ESC[0m"
    ]