{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}

module Taiwan.ID.Region
  ( Region
  , fromChar
  , fromLetter
  , toChar
  , toLetter
  , toText
  , generate
  ) where

import Control.Monad.Random.Class
  ( MonadRandom (..) )
import Data.Finitary
  ( Finitary )
import Data.Text
  ( Text )
import GHC.Generics
  ( Generic )
import Taiwan.ID.Language
  ( Language (..) )
import Taiwan.ID.Letter
  ( Letter (..) )
import Taiwan.ID.Utilities
  ( randomFinitary )
import Text.Read
  ( Lexeme (Ident, Symbol), Read (readPrec), lexP, parens, prec )

import qualified Taiwan.ID.Letter as Letter

-- |
-- $setup
-- >>> import qualified Taiwan.ID.Region as Region

-- | Represents a geographical region.
--
-- == Region codes
--
-- Every region has a unique letter code:
--
-- +------+---------+-------------------+
-- | Code | Chinese | English           |
-- +======+=========+===================+
-- | @A@  | 臺北市     | Taipei City       |
-- +------+---------+-------------------+
-- | @B@  | 臺中市     | Taichung City     |
-- +------+---------+-------------------+
-- | @C@  | 基隆市     | Keelung City      |
-- +------+---------+-------------------+
-- | @D@  | 臺南市     | Tainan City       |
-- +------+---------+-------------------+
-- | @E@  | 高雄市     | Kaohsiung City    |
-- +------+---------+-------------------+
-- | @F@  | 新北市     | New Taipei City   |
-- +------+---------+-------------------+
-- | @G@  | 宜蘭縣     | Yilan County      |
-- +------+---------+-------------------+
-- | @H@  | 桃園市     | Taoyuan City      |
-- +------+---------+-------------------+
-- | @I@  | 嘉義市     | Chiayi City       |
-- +------+---------+-------------------+
-- | @J@  | 新竹縣     | Hsinchu County    |
-- +------+---------+-------------------+
-- | @K@  | 苗栗縣     | Miaoli County     |
-- +------+---------+-------------------+
-- | @L@  | 臺中縣     | Taichung County   |
-- +------+---------+-------------------+
-- | @M@  | 南投縣     | Nantou County     |
-- +------+---------+-------------------+
-- | @N@  | 彰化縣     | Changhua County   |
-- +------+---------+-------------------+
-- | @O@  | 新竹市     | Hsinchu City      |
-- +------+---------+-------------------+
-- | @P@  | 雲林縣     | Yunlin County     |
-- +------+---------+-------------------+
-- | @Q@  | 嘉義縣     | Chiayi County     |
-- +------+---------+-------------------+
-- | @R@  | 臺南縣     | Tainan County     |
-- +------+---------+-------------------+
-- | @S@  | 高雄縣     | Kaohsiung County  |
-- +------+---------+-------------------+
-- | @T@  | 屏東縣     | Pingtung County   |
-- +------+---------+-------------------+
-- | @U@  | 花蓮縣     | Hualien County    |
-- +------+---------+-------------------+
-- | @V@  | 臺東縣     | Taitung County    |
-- +------+---------+-------------------+
-- | @W@  | 金門縣     | Kinmen County     |
-- +------+---------+-------------------+
-- | @X@  | 澎湖縣     | Penghu County     |
-- +------+---------+-------------------+
-- | @Y@  | 陽明山     | Yangmingshan      |
-- +------+---------+-------------------+
-- | @Z@  | 連江縣     | Lienchiang County |
-- +------+---------+-------------------+
--
-- == Usage
--
-- To construct a 'Region' from its letter code, use the 'fromLetter'
-- function.
--
-- To print the full name of a 'Region', use the 'toText' function.
--
-- To generate a random 'Region', use the 'generate' function.
--
newtype Region = Region Letter
  deriving stock (Region -> Region -> Bool
(Region -> Region -> Bool)
-> (Region -> Region -> Bool) -> Eq Region
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Region -> Region -> Bool
== :: Region -> Region -> Bool
$c/= :: Region -> Region -> Bool
/= :: Region -> Region -> Bool
Eq, (forall x. Region -> Rep Region x)
-> (forall x. Rep Region x -> Region) -> Generic Region
forall x. Rep Region x -> Region
forall x. Region -> Rep Region x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Region -> Rep Region x
from :: forall x. Region -> Rep Region x
$cto :: forall x. Rep Region x -> Region
to :: forall x. Rep Region x -> Region
Generic, Eq Region
Eq Region =>
(Region -> Region -> Ordering)
-> (Region -> Region -> Bool)
-> (Region -> Region -> Bool)
-> (Region -> Region -> Bool)
-> (Region -> Region -> Bool)
-> (Region -> Region -> Region)
-> (Region -> Region -> Region)
-> Ord Region
Region -> Region -> Bool
Region -> Region -> Ordering
Region -> Region -> Region
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Region -> Region -> Ordering
compare :: Region -> Region -> Ordering
$c< :: Region -> Region -> Bool
< :: Region -> Region -> Bool
$c<= :: Region -> Region -> Bool
<= :: Region -> Region -> Bool
$c> :: Region -> Region -> Bool
> :: Region -> Region -> Bool
$c>= :: Region -> Region -> Bool
>= :: Region -> Region -> Bool
$cmax :: Region -> Region -> Region
max :: Region -> Region -> Region
$cmin :: Region -> Region -> Region
min :: Region -> Region -> Region
Ord)
  deriving newtype (Region
Region -> Region -> Bounded Region
forall a. a -> a -> Bounded a
$cminBound :: Region
minBound :: Region
$cmaxBound :: Region
maxBound :: Region
Bounded, Int -> Region
Region -> Int
Region -> [Region]
Region -> Region
Region -> Region -> [Region]
Region -> Region -> Region -> [Region]
(Region -> Region)
-> (Region -> Region)
-> (Int -> Region)
-> (Region -> Int)
-> (Region -> [Region])
-> (Region -> Region -> [Region])
-> (Region -> Region -> [Region])
-> (Region -> Region -> Region -> [Region])
-> Enum Region
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Region -> Region
succ :: Region -> Region
$cpred :: Region -> Region
pred :: Region -> Region
$ctoEnum :: Int -> Region
toEnum :: Int -> Region
$cfromEnum :: Region -> Int
fromEnum :: Region -> Int
$cenumFrom :: Region -> [Region]
enumFrom :: Region -> [Region]
$cenumFromThen :: Region -> Region -> [Region]
enumFromThen :: Region -> Region -> [Region]
$cenumFromTo :: Region -> Region -> [Region]
enumFromTo :: Region -> Region -> [Region]
$cenumFromThenTo :: Region -> Region -> Region -> [Region]
enumFromThenTo :: Region -> Region -> Region -> [Region]
Enum)
  deriving anyclass Eq Region
KnownNat (Cardinality Region)
(Eq Region, KnownNat (Cardinality Region)) =>
(Finite (Cardinality Region) -> Region)
-> (Region -> Finite (Cardinality Region))
-> ((1 <= Cardinality Region) => Region)
-> ((1 <= Cardinality Region) => Region)
-> (Region -> Maybe Region)
-> (Region -> Maybe Region)
-> Finitary Region
(1 <= Cardinality Region) => Region
Finite (Cardinality Region) -> Region
Region -> Maybe Region
Region -> Finite (Cardinality Region)
forall a.
(Eq a, KnownNat (Cardinality a)) =>
(Finite (Cardinality a) -> a)
-> (a -> Finite (Cardinality a))
-> ((1 <= Cardinality a) => a)
-> ((1 <= Cardinality a) => a)
-> (a -> Maybe a)
-> (a -> Maybe a)
-> Finitary a
$cfromFinite :: Finite (Cardinality Region) -> Region
fromFinite :: Finite (Cardinality Region) -> Region
$ctoFinite :: Region -> Finite (Cardinality Region)
toFinite :: Region -> Finite (Cardinality Region)
$cstart :: (1 <= Cardinality Region) => Region
start :: (1 <= Cardinality Region) => Region
$cend :: (1 <= Cardinality Region) => Region
end :: (1 <= Cardinality Region) => Region
$cprevious :: Region -> Maybe Region
previous :: Region -> Maybe Region
$cnext :: Region -> Maybe Region
next :: Region -> Maybe Region
Finitary

instance Read Region where
  readPrec :: ReadPrec Region
readPrec = ReadPrec Region -> ReadPrec Region
forall a. ReadPrec a -> ReadPrec a
parens (ReadPrec Region -> ReadPrec Region)
-> ReadPrec Region -> ReadPrec Region
forall a b. (a -> b) -> a -> b
$ Int -> ReadPrec Region -> ReadPrec Region
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
10 (ReadPrec Region -> ReadPrec Region)
-> ReadPrec Region -> ReadPrec Region
forall a b. (a -> b) -> a -> b
$ do
    Ident "Region"     <- ReadPrec Lexeme
lexP
    Symbol "."         <- lexP
    Ident "fromLetter" <- lexP
    fromLetter <$> readPrec

instance Show Region where
  showsPrec :: Int -> Region -> [Char] -> [Char]
showsPrec Int
d Region
s =
    Bool -> ([Char] -> [Char]) -> [Char] -> [Char]
showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) (([Char] -> [Char]) -> [Char] -> [Char])
-> ([Char] -> [Char]) -> [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$
      [Char] -> [Char] -> [Char]
showString [Char]
"Region.fromLetter " ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Letter -> [Char] -> [Char]
forall a. Show a => a -> [Char] -> [Char]
shows (Region -> Letter
toLetter Region
s)

-- | Attempts to construct a 'Region' from its corresponding letter code as a
-- 'Char'.
--
-- >>> Region.fromChar 'A'
-- Just (Region.fromLetter A)
--
-- >>> Region.fromChar '?'
-- Nothing
--
fromChar :: Char -> Maybe Region
fromChar :: Char -> Maybe Region
fromChar = (Letter -> Region) -> Maybe Letter -> Maybe Region
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Letter -> Region
fromLetter (Maybe Letter -> Maybe Region)
-> (Char -> Maybe Letter) -> Char -> Maybe Region
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Maybe Letter
Letter.fromChar

-- | Constructs a 'Region' from its corresponding letter code.
--
fromLetter :: Letter -> Region
fromLetter :: Letter -> Region
fromLetter = Letter -> Region
Region

-- | Converts a 'Region' to its corresponding letter code as a 'Char'.
--
toChar :: Region -> Char
toChar :: Region -> Char
toChar = Letter -> Char
Letter.toChar (Letter -> Char) -> (Region -> Letter) -> Region -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Region -> Letter
toLetter

-- | Converts a 'Region' to its corresponding letter code.
--
toLetter :: Region -> Letter
toLetter :: Region -> Letter
toLetter (Region Letter
letter) = Letter
letter

-- | Prints the specified 'Region'.
toText :: Language -> Region -> Text
toText :: Language -> Region -> Text
toText = \case
  Language
English -> Region -> Text
toTextEnglish
  Language
Chinese -> Region -> Text
toTextChinese

toTextChinese :: Region -> Text
toTextChinese :: Region -> Text
toTextChinese (Region Letter
letter) = case Letter
letter of
  Letter
A -> Text
"臺北市"
  Letter
B -> Text
"臺中市"
  Letter
C -> Text
"基隆市"
  Letter
D -> Text
"臺南市"
  Letter
E -> Text
"高雄市"
  Letter
F -> Text
"新北市"
  Letter
G -> Text
"宜蘭縣"
  Letter
H -> Text
"桃園市"
  Letter
I -> Text
"嘉義市"
  Letter
J -> Text
"新竹縣"
  Letter
K -> Text
"苗栗縣"
  Letter
L -> Text
"臺中縣"
  Letter
M -> Text
"南投縣"
  Letter
N -> Text
"彰化縣"
  Letter
O -> Text
"新竹市"
  Letter
P -> Text
"雲林縣"
  Letter
Q -> Text
"嘉義縣"
  Letter
R -> Text
"臺南縣"
  Letter
S -> Text
"高雄縣"
  Letter
T -> Text
"屏東縣"
  Letter
U -> Text
"花蓮縣"
  Letter
V -> Text
"臺東縣"
  Letter
W -> Text
"金門縣"
  Letter
X -> Text
"澎湖縣"
  Letter
Y -> Text
"陽明山"
  Letter
Z -> Text
"連江縣"

toTextEnglish :: Region -> Text
toTextEnglish :: Region -> Text
toTextEnglish (Region Letter
letter) = case Letter
letter of
  Letter
A -> Text
"Taipei City"
  Letter
B -> Text
"Taichung City"
  Letter
C -> Text
"Keelung City"
  Letter
D -> Text
"Tainan City"
  Letter
E -> Text
"Kaohsiung City"
  Letter
F -> Text
"New Taipei City"
  Letter
G -> Text
"Yilan County"
  Letter
H -> Text
"Taoyuan City"
  Letter
I -> Text
"Chiayi City"
  Letter
J -> Text
"Hsinchu County"
  Letter
K -> Text
"Miaoli County"
  Letter
L -> Text
"Taichung County"
  Letter
M -> Text
"Nantou County"
  Letter
N -> Text
"Changhua County"
  Letter
O -> Text
"Hsinchu City"
  Letter
P -> Text
"Yunlin County"
  Letter
Q -> Text
"Chiayi County"
  Letter
R -> Text
"Tainan County"
  Letter
S -> Text
"Kaohsiung County"
  Letter
T -> Text
"Pingtung County"
  Letter
U -> Text
"Hualien County"
  Letter
V -> Text
"Taitung County"
  Letter
W -> Text
"Kinmen County"
  Letter
X -> Text
"Penghu County"
  Letter
Y -> Text
"Yangmingshan"
  Letter
Z -> Text
"Lienchiang County"

-- | Generates a random 'Region'.
--
generate :: MonadRandom m => m Region
generate :: forall (m :: * -> *). MonadRandom m => m Region
generate = m Region
forall (m :: * -> *) a.
(MonadRandom m, Finitary a, 1 <= Cardinality a) =>
m a
randomFinitary