{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedLists #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE TupleSections #-}

-- base
import qualified Data.Monoid as Monoid
import Data.Ord
import qualified Data.Semigroup as Semigroup

-- cassava
import Data.Csv

-- generic-deriving
import Generics.Deriving.Semigroup

-- hable
import qualified Hable

-- rio
import RIO
import qualified RIO.ByteString.Lazy as BL
import qualified RIO.Char as Char
import qualified RIO.List as List
import qualified RIO.Map as Map
import qualified RIO.Text as Text
import RIO.Time

-- vector
import qualified Data.Vector as Vector

-- the location column wraps "Text" and parses using its instance
newtype Location = Location {getLocation :: Text}
  deriving (FromField, Show, Read, Eq, Ord)

-- the operator column wraps "Text" and parses using its instance
newtype Operator = Operator {getOperator :: Text}
  deriving (FromField, Show, Read, Eq, Ord)

-- the flight number column wraps "Text" and parses using its instance
newtype FlightNumber = FlightNumber {getFlightNumber :: Text}
  deriving (FromField, Show, Read, Eq, Ord)

-- the A/C type column wraps "Text" and parses using its instance
newtype AcType = AcType {getAcType :: Text}
  deriving (FromField, Show, Read, Eq, Ord)

-- the fatalities column wraps "Int" and parses using its instance
newtype Fatalities = Fatalities {getFatalities :: Int}
  deriving (FromField, Show, Read, Eq, Ord, Num)

-- Our date column wraps "Day" but parses as Y/M/D from the CSV
newtype Date = Date {getDay :: Day}
  deriving (Eq, Ord, Show, Read)

-- the date format definition used by the pretty printer and parser
mkDateFmt :: (TimeLocale -> String -> b) -> b
mkDateFmt f = f defaultTimeLocale "%m/%d/%Y"

-- pretty print the date in the same way that its read from the CSV
prettyDate :: Date -> String
prettyDate = mkDateFmt formatTime . getDay

-- customize the CSV parser for the date
instance FromField Date where
    --  types
    --   parseField :: FromField a => Field -> Parser a
    --   parseTimeM
    --    :: (Monad m, ParseTime t)
    --    => Bool -> TimeLocale -> String -> String -> m t
    --   >=> :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
  parseField =
    parseField >=>
      ( (Date <$>) .  mkDateFmt (parseTimeM True) )

-- the data type that represents a row in the CSV that we will parse
data CsvRow = CsvRow
  { date :: Date
  , location :: Location
  , operator :: Operator
  , flightNumber :: Maybe FlightNumber
  , acType :: AcType
  , fatalities :: Maybe Fatalities
  } deriving (Generic)

-- We define how to parse a CSV file making use of "genericParseNamedRecord"
-- to do this automatically for us because "CsvRow" is an instance of "Generic"
-- we only customized the definition of the labels
instance FromNamedRecord CsvRow where
  parseNamedRecord =
    -- types
    --   genericParseNamedRecord
    --    :: (Generic a, GFromNamedRecord (Rep a))
    --    => Options -> NamedRecord -> Parser a
    --   fieldLabelModifier :: String -> String
    genericParseNamedRecord
      defaultOptions
        { fieldLabelModifier =
            \case
              "flightNumber" -> "Flight #"
              "acType" -> "Type"
              h:t -> Char.toUpper h : t
              [] -> []
        }

-- a type to represent the number of crashes reported
newtype Crashes = Crashes {getCrashes :: Int}
  deriving (Num, Show, Read, Ord, Eq)

-- a data type for the statistic we want to record per row type
data Stats = Stats
  { statFirst :: Semigroup.Min Date          -- lower bound Date
  , statLast :: Semigroup.Max Date           -- upper bound Date
  , statFatalities :: Monoid.Sum Fatalities  -- sum of Fatalities
  , statCrashes :: Monoid.Sum Crashes        -- sum of Crashes
  } deriving (Generic, Show)

-- Generically derive a "Semigroup" instance for "Stats" using "Generic" and
-- the fact that each field has a "Semigroup" instance
instance Semigroup Stats where
  (<>)  = gsappenddefault


-- convert a CSV row into a statistic we can aggregate
rowToStats ::  CsvRow -> Stats
rowToStats CsvRow {  date , fatalities} =
   Stats
      { statFirst      = Semigroup.Min date
      , statLast       = Semigroup.Max date
      , statFatalities = Semigroup.Sum (fromMaybe 0 fatalities)
      , statCrashes    = Semigroup.Sum 1
      }

-- display a "Stats" as a row of columns of "String"
displayStatsColumns :: Stats -> [String]
displayStatsColumns  =
  -- types:
  --   sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
  -- inferred concrete types:
  --   sequence :: [Stats -> String] -> Stats -> [String]
  sequence
    [ prettyDate . Semigroup.getMin . statFirst
    , prettyDate . Semigroup.getMax . statLast
    , show . getFatalities . Semigroup.getSum . statFatalities
    , show . getCrashes . Semigroup.getSum . statCrashes
    ]

-- the column headers associated with rows of columns of strings of "Stats"
statsHeaders :: [String]
statsHeaders = ["first", "last", "fatalities", "crashes"]

-- group rows on some value aggregating statistics using some "Semigroup"
aggregateStatisticsBy
  :: (Ord groupBy, Semigroup statistic)
  => (row -> Maybe (groupBy, statistic))
  -> [row]
  -> [(groupBy, statistic)]
aggregateStatisticsBy grouper =
  -- types:
  --   toList :: Map k a -> [(k, a)]
  --   <> :: Semigroup a => a -> a -> a
  --   fromListWith :: Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
  --   mapMaybe :: (a -> Maybe b) -> [a] -> [b]
    -- :: Map a Stats -> [(a, Stats)]
    Map.toList .
    -- :: [(a, Stats)] -> Map a Stats
    Map.fromListWith (<>) .
    -- :: [CsvRow] -> [(a, Stats)]
    mapMaybe grouper

-- group the CSV rows aggregating the statistics and displaying the "n" best ranked stats
groupAndDisplayStats
  :: (Ord o, Ord a)
  => (CsvRow -> Maybe (a, Stats)) -- grouping function
  -> String                       -- grouping column header
  -> (a -> String)                -- display grouping column
  -> (Stats -> o)                 -- ordering function
  -> Int                          -- number of rows to display
  -> [CsvRow]                     -- the CSV rows
  -> String
groupAndDisplayStats grouper groupName displayGroup ordering cnt rows =
  -- types:
  --   hable :: Config style -> [[String]] -> String
  --   take :: Int -> [a] -> [a]
  --   map :: (a -> b) -> [a] -> [b]
  --   snd :: (a, b) -> b
  --   sortOn :: Ord b => (a -> b) -> [a] -> [a]
    Hable.hable Hable.defaultConfig $
    (groupName : statsHeaders) :
    ( take cnt .
      --  :: [(a, Stats)] -> [[String]]
      map
        (\(g, stats) ->
          displayGroup g : displayStatsColumns stats
        ) .
      -- :: [(a, Stats)] -> [(a, Stats)]
      List.sortOn (ordering . snd) .
      -- :: [CsvRow] -> [(a, Stats)]
      aggregateStatisticsBy grouper $
      -- :: [CsvRow]
      rows
    )

statsByOperator :: CsvRow -> Maybe (Operator, Stats)
statsByOperator row = Just ( operator row , rowToStats row)

statsByFlightNumber :: CsvRow -> Maybe (FlightNumber,  Stats)
statsByFlightNumber row = (,rowToStats row) <$> flightNumber row

statsByLocation :: CsvRow -> Maybe (Location, Stats)
statsByLocation row = Just ( location row , rowToStats row)

statsAcType :: CsvRow -> Maybe (AcType, Stats)
statsAcType row = Just ( acType row , rowToStats row)

byMostFatalities :: Stats -> Down Fatalities
byMostFatalities = Down . Semigroup.getSum . statFatalities

byLeastFatalities :: Stats -> Fatalities
byLeastFatalities = Semigroup.getSum . statFatalities

bySafestToCrashWith :: Stats -> (Fatalities, Down Crashes)
bySafestToCrashWith Stats{statFatalities, statCrashes} =
  (Semigroup.getSum statFatalities, Down (Semigroup.getSum statCrashes))

main :: IO ()
main = do
  csvData <- BL.readFile "./Airplane_Crashes_and_Fatalities_Since_1908.csv"
  rows <-
    either fail (pure . Vector.toList . snd) $ decodeByName csvData

  putStrLn "5 deadliest operators"
  putStr $
    groupAndDisplayStats
      statsByOperator "operator" (Text.unpack . getOperator) byMostFatalities 5 rows

  putStrLn "5 safest operators"
  putStr $
    groupAndDisplayStats
      statsByOperator "operator" (Text.unpack . getOperator) byLeastFatalities 5 rows


  putStrLn "6 deadliest flight numbers"
  putStr $
    groupAndDisplayStats
      statsByFlightNumber "flight #" (Text.unpack . getFlightNumber) byMostFatalities 6 rows

  putStrLn "4 deadliest locations"
  putStr $
    groupAndDisplayStats
      statsByLocation "location" (Text.unpack . getLocation) byMostFatalities 4 rows

  putStrLn "5 deadliest A/C Types"
  putStr $
    groupAndDisplayStats
      statsAcType "A/C Type" (Text.unpack . getAcType) byMostFatalities 5 rows


  putStrLn "5 best A/C Types to crash with"
  putStr $
    groupAndDisplayStats
      statsAcType "A/C Type" (Text.unpack . getAcType) bySafestToCrashWith 5 rows