module PureScript.Wellknown
  ( primString
  , dataMapEmpty
  , stringLiteral
  , nonEmptyStringLiteral
  , stringSingleton
  , nonEmptyString
  , arrayLiteral
  , call
  , variable
  , definition
  , tag
  , pTypeWithArgument
  , pTypeFrom
  , PType
  , Expr
  , structuredUrlPathAndSearchParams
  , structuredUrlFromPath
  ) where

import Data.Array.NonEmpty as NonEmptyArray
import Data.Map as Map
import Data.String as String
import Data.String.NonEmpty (NonEmptyString)
import Data.String.NonEmpty as NonEmptyString
import Prelude as Prelude
import PureScript.Data as Data
import StructuredUrl as StructuredUrl
import Type.Proxy (Proxy(..))

data PType :: Type -> Type
-- | PureScript の型. 型を間違えないように, 型を幽霊型としてつけている
data PType pType
  = PType Data.TypeData

data Expr :: Type -> Type
-- | PureScript の式. 型を間違えないように, 型を幽霊型としてつけている
data Expr pType
  = Expr Data.ExprData

-- | Prim
-- | https://pursuit.purescript.org/builtins/docs/Prim
primModuleName :: Data.ModuleName
primModuleName =
  Data.ModuleName
    ( NonEmptyArray.singleton
        (NonEmptyString.nes (Proxy :: _ "Prim"))
    )

-- | https://pursuit.purescript.org/builtins/docs/Prim#t:String
primString :: PType String
primString =
  PType
    ( Data.TypeData
        { moduleName: primModuleName
        , name: NonEmptyString.nes (Proxy :: _ "String")
        }
    )

-- | Data.Map
-- | https://pursuit.purescript.org/packages/purescript-ordered-collections/2.0.2/docs/Data.Map
dataMapModuleName :: Data.ModuleName
dataMapModuleName =
  Data.ModuleName
    ( NonEmptyArray.cons' (NonEmptyString.nes (Proxy :: _ "Data"))
        [ NonEmptyString.nes (Proxy :: _ "Map") ]
    )

-- | https://pursuit.purescript.org/packages/purescript-ordered-collections/2.0.2/docs/Data.Map#v:empty
dataMapEmpty :: forall k v. Expr (Map.Map k v)
dataMapEmpty =
  Expr
    ( Data.Variable
        { moduleName: dataMapModuleName
        , name: NonEmptyString.nes (Proxy :: _ "empty")
        }
    )

-- | Data.String.NonEmpty
-- | https://pursuit.purescript.org/packages/purescript-strings/5.0.0/docs/Data.String.NonEmpty
dataStringNonEmptyModuleName :: Data.ModuleName
dataStringNonEmptyModuleName =
  Data.ModuleName
    ( NonEmptyArray.cons' (NonEmptyString.nes (Proxy :: _ "Data"))
        [ NonEmptyString.nes (Proxy :: _ "String")
        , NonEmptyString.nes (Proxy :: _ "NonEmpty")
        ]
    )

dataStringModuleName :: Data.ModuleName
dataStringModuleName =
  Data.ModuleName
    ( NonEmptyArray.cons' (NonEmptyString.nes (Proxy :: _ "Data"))
        [ NonEmptyString.nes (Proxy :: _ "String") ]
    )

-- | https://pursuit.purescript.org/packages/purescript-strings/5.0.0/docs/Data.String#v:singleton
stringSingleton :: Expr String.CodePoint -> Expr String
stringSingleton (Expr codePoint) =
  Expr
    ( Data.Call
        { function:
            Data.Variable
              { moduleName: dataStringModuleName
              , name: NonEmptyString.nes (Proxy :: _ "singleton")
              }
        , argument: codePoint
        }
    )

-- | https://pursuit.purescript.org/packages/purescript-strings/5.0.0/docs/Data.String.NonEmpty.Internal#v:nes
nonEmptyStringNes :: Data.ExprData -> Data.ExprData
nonEmptyStringNes proxy =
  Data.Call
    { function:
        Data.Variable
          { moduleName: dataStringNonEmptyModuleName
          , name: NonEmptyString.nes (Proxy :: _ "nes")
          }
    , argument: proxy
    }

-- | Type.Proxy
-- | https://pursuit.purescript.org/packages/purescript-prelude/5.0.1/docs/Type.Proxy
typeProxyModuleName :: Data.ModuleName
typeProxyModuleName =
  Data.ModuleName
    ( NonEmptyArray.cons' (NonEmptyString.nes (Proxy :: _ "Type"))
        [ NonEmptyString.nes (Proxy :: _ "Proxy") ]
    )

-- | Proxy :: _ "{str}"
proxyProxyWithTypeAnotation :: String -> Data.ExprData
proxyProxyWithTypeAnotation str =
  Data.TypeAnnotation
    { expr: Data.Variable { moduleName: typeProxyModuleName, name: NonEmptyString.nes (Proxy :: _ "Proxy") }
    , pType:
        Data.TypeWithArgument
          { function:
              Data.TypeData
                { moduleName: typeProxyModuleName
                , name: NonEmptyString.nes (Proxy :: _ "Proxy")
                }
          , argument: Data.SymbolLiteral str
          }
    }

-- | ```purs
-- | "{str}"
-- | ```
stringLiteral :: String -> Expr String
stringLiteral str = Expr (Data.StringLiteral str)

-- | ```purs
-- | NonEmptyString.nes (Proxy :: _ "{str}")
-- | ```
nonEmptyStringLiteral :: NonEmptyString -> Expr NonEmptyString
nonEmptyStringLiteral str =
  Expr
    ( nonEmptyStringNes
        ( proxyProxyWithTypeAnotation
            (NonEmptyString.toString str)
        )
    )

nonEmptyString :: PType NonEmptyString
nonEmptyString =
  PType
    ( Data.TypeData
        { moduleName: dataStringNonEmptyModuleName
        , name: NonEmptyString.nes (Proxy :: _ "NonEmptyString")
        }
    )

arrayLiteral :: forall t. Array (Expr t) -> Expr (Array t)
arrayLiteral list =
  Expr
    ( Data.ArrayLiteral
        (Prelude.map (\(Expr exprData) -> exprData) list)
    )

call :: forall input output. Expr (input -> output) -> Expr input -> Expr output
call (Expr function) (Expr argument) =
  Expr
    ( Data.Call
        { function, argument }
    )

variable :: forall t. { moduleName :: Data.ModuleName, name :: NonEmptyString } -> Expr t
variable option = Expr (Data.Variable option)

tag :: forall t. { moduleName :: Data.ModuleName, name :: NonEmptyString } -> Expr t
tag option = Expr (Data.Tag option)

definition ::
  forall t.
  { name :: NonEmptyString
  , document :: String
  , pType :: PType t
  , expr :: Expr t
  , isExport :: Boolean
  } ->
  Data.Definition
definition option =
  let
    (Expr exprData) = option.expr

    (PType typeData) = option.pType
  in
    Data.Definition
      { name: option.name
      , document: option.document
      , typeData: typeData
      , exprData: exprData
      , isExport: option.isExport
      }

pTypeFrom ::
  forall t.
  { moduleName :: Data.ModuleName
  , name :: NonEmptyString
  } ->
  PType t
pTypeFrom option =
  PType
    (Data.TypeData option)

pTypeWithArgument :: forall input output. PType (input -> output) -> PType input -> PType output
pTypeWithArgument (PType function) (PType argument) =
  PType
    (Data.TypeWithArgument { function, argument })

-- | ```purs
-- | StructuredUrl.fromPath
-- | ```
structuredUrlFromPath :: Expr (Array NonEmptyString -> StructuredUrl.PathAndSearchParams)
structuredUrlFromPath =
  variable
    { moduleName:
        Data.ModuleName
          ( NonEmptyArray.singleton
              ( NonEmptyString.nes
                  (Proxy :: _ "StructuredUrl")
              )
          )
    , name: NonEmptyString.nes (Proxy :: _ "fromPath")
    }

structuredUrlPathAndSearchParams :: PType (StructuredUrl.PathAndSearchParams)
structuredUrlPathAndSearchParams =
  pTypeFrom
    { moduleName:
        Data.ModuleName
          ( NonEmptyArray.singleton
              (NonEmptyString.nes (Proxy :: _ "StructuredUrl"))
          )
    , name: NonEmptyString.nes (Proxy :: _ "PathAndSearchParams")
    }