{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
-- For Inferable
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE NoMonomorphismRestriction #-}
{-# OPTIONS_GHC -Wno-missing-signatures #-}

module Examples.Ex02 where

import Data.Either (Either (..))
import Data.Eq (Eq)
import Data.Function (($), (.))
import Data.Maybe (Maybe (..))
import Data.Set (Set)
import Data.Set qualified as Set
import GHC.Generics (Generic)
import Network.URI.Slug qualified as URI
import Symantic.Classes (
  Inferable (..),
  Iso (..),
  IsoFunctor (..),
  Optionable (..),
  ProductFunctor (..),
  SumFunctor (..),
  adt,
 )
import Symantic.Reader (Reader (..))
import Text.Show (Show)

import Webc

data Site
  = SiteStatic
  | SiteFeeds
  | SiteFilter Filter
  -- SitePage [URI.Slug]
  -- SiteSpecial [URI.Slug]
  deriving (Eq, Show, Generic)

instance Renderable Site where
  render Comp{..} = case compValue of
    SiteFeeds -> Right ("feeds", "txt")
    SiteFilter _fil -> Right ("filter", "txt")
    SiteStatic -> Left $ pathOfSlugs compSlugs

gen0 :: [Gen Site]
gen0 = generate (unReader site model0)

enc0 :: [URI.Slug]
enc0 =
  encode (unReader site model0) $
    SiteFilter
      Filter
        { filterLang = Just LangFr
        , filterTag = Nothing
        }

site =
  adt @Site $
    literalSlug "static"
      <+> literalSlug "feed"
      <+> "filter" </> infer

-- <+>
-- ("page" </> many1 (captureSlug "page"))
-- <+>
-- ("special" </> many1 (captureSlug "page"))

-- Type 'Filter'
data Filter = Filter
  { filterLang :: Maybe Lang
  , filterTag :: Maybe Tag
  }
  deriving (Eq, Show, Generic)

instance
  ( IsoFunctor repr
  , ProductFunctor repr
  , SumFunctor repr
  , Slugable repr
  , Optionable repr
  , -- , Endable repr
    Inferable Tag repr
  ) =>
  Inferable Filter repr
  where
  infer = adt @Filter $ adt (literalSlug "all" <+> infer) <.> optional infer

-- * Type 'Lang'
data Lang = LangEn | LangFr deriving (Eq, Show, Generic)
instance (IsoFunctor repr, SumFunctor repr, Slugable repr) => Inferable Lang repr where
  infer = adt @Lang $ literalSlug "fr" <+> literalSlug "en"

-- * Type 'Model'
data Model = Model
  { modelTags :: Set URI.Slug
  }

model0 :: Model
model0 = Model{modelTags = Set.fromList ["tag0", "tag1"]}

-- * Type 'Tag'
newtype Tag = Tag {unTag :: URI.Slug} deriving (Eq, Show)

instance (IsoFunctor repr, Slugable repr) => Inferable Tag (Reader Model repr) where
  infer = Reader $ (Iso Tag unTag <%>) . chooseSlug . modelTags