{-# LANGUAGE FlexibleContexts, FlexibleInstances, MultiParamTypeClasses #-}

module Opaleye.SQLite.Join where

import qualified Opaleye.SQLite.Internal.Unpackspec as U
import qualified Opaleye.SQLite.Internal.Join as J
import qualified Opaleye.SQLite.Internal.Tag as T
import qualified Opaleye.SQLite.Internal.PrimQuery as PQ
import           Opaleye.SQLite.QueryArr (Query)
import qualified Opaleye.SQLite.Internal.QueryArr as Q
import           Opaleye.SQLite.Internal.Column (Column(Column))
import qualified Opaleye.SQLite.PGTypes as T

import qualified Data.Profunctor.Product.Default as D

-- | @leftJoin@'s use of the 'D.Default' typeclass means that the
-- compiler will have trouble inferring types.  It is strongly
-- recommended that you provide full type signatures when using
-- @leftJoin@.
--
-- Example specialization:
--
-- @
-- leftJoin :: Query (Column a, Column b)
--          -> Query (Column c, Column (Nullable d))
--          -> (((Column a, Column b), (Column c, Column (Nullable d))) -> Column 'Opaleye.PGTypes.PGBool')
--          -> Query ((Column a, Column b), (Column (Nullable c), Column (Nullable d)))
-- @
leftJoin  :: (D.Default U.Unpackspec columnsA columnsA,
              D.Default U.Unpackspec columnsB columnsB,
              D.Default J.NullMaker columnsB nullableColumnsB) =>
             Query columnsA -> Query columnsB
          -> ((columnsA, columnsB) -> Column T.PGBool)
          -> Query (columnsA, nullableColumnsB)
leftJoin :: Query columnsA
-> Query columnsB
-> ((columnsA, columnsB) -> Column PGBool)
-> Query (columnsA, nullableColumnsB)
leftJoin = Unpackspec columnsA columnsA
-> Unpackspec columnsB columnsB
-> NullMaker columnsB nullableColumnsB
-> Query columnsA
-> Query columnsB
-> ((columnsA, columnsB) -> Column PGBool)
-> Query (columnsA, nullableColumnsB)
forall columnsA columnsB nullableColumnsB.
Unpackspec columnsA columnsA
-> Unpackspec columnsB columnsB
-> NullMaker columnsB nullableColumnsB
-> Query columnsA
-> Query columnsB
-> ((columnsA, columnsB) -> Column PGBool)
-> Query (columnsA, nullableColumnsB)
leftJoinExplicit Unpackspec columnsA columnsA
forall (p :: * -> * -> *) a b. Default p a b => p a b
D.def Unpackspec columnsB columnsB
forall (p :: * -> * -> *) a b. Default p a b => p a b
D.def NullMaker columnsB nullableColumnsB
forall (p :: * -> * -> *) a b. Default p a b => p a b
D.def

-- We don't actually need the Unpackspecs any more, but I'm going to
-- leave them here in case they're ever needed again.  I don't want to
-- have to break the API to add them back.
leftJoinExplicit :: U.Unpackspec columnsA columnsA
                 -> U.Unpackspec columnsB columnsB
                 -> J.NullMaker columnsB nullableColumnsB
                 -> Query columnsA -> Query columnsB
                 -> ((columnsA, columnsB) -> Column T.PGBool)
                 -> Query (columnsA, nullableColumnsB)
leftJoinExplicit :: Unpackspec columnsA columnsA
-> Unpackspec columnsB columnsB
-> NullMaker columnsB nullableColumnsB
-> Query columnsA
-> Query columnsB
-> ((columnsA, columnsB) -> Column PGBool)
-> Query (columnsA, nullableColumnsB)
leftJoinExplicit Unpackspec columnsA columnsA
_ Unpackspec columnsB columnsB
_ NullMaker columnsB nullableColumnsB
nullmaker Query columnsA
qA Query columnsB
qB (columnsA, columnsB) -> Column PGBool
cond = (((), Tag) -> ((columnsA, nullableColumnsB), PrimQuery, Tag))
-> Query (columnsA, nullableColumnsB)
forall a b. ((a, Tag) -> (b, PrimQuery, Tag)) -> QueryArr a b
Q.simpleQueryArr ((), Tag) -> ((columnsA, nullableColumnsB), PrimQuery, Tag)
q where
  q :: ((), Tag) -> ((columnsA, nullableColumnsB), PrimQuery, Tag)
q ((), Tag
startTag) = ((columnsA
columnsA, nullableColumnsB
nullableColumnsB), PrimQuery
primQueryR, Tag -> Tag
T.next Tag
endTag)
    where (columnsA
columnsA, PrimQuery
primQueryA, Tag
midTag) = Query columnsA -> ((), Tag) -> (columnsA, PrimQuery, Tag)
forall a b. QueryArr a b -> (a, Tag) -> (b, PrimQuery, Tag)
Q.runSimpleQueryArr Query columnsA
qA ((), Tag
startTag)
          (columnsB
columnsB, PrimQuery
primQueryB, Tag
endTag) = Query columnsB -> ((), Tag) -> (columnsB, PrimQuery, Tag)
forall a b. QueryArr a b -> (a, Tag) -> (b, PrimQuery, Tag)
Q.runSimpleQueryArr Query columnsB
qB ((), Tag
midTag)

          nullableColumnsB :: nullableColumnsB
nullableColumnsB = NullMaker columnsB nullableColumnsB -> columnsB -> nullableColumnsB
forall a b. NullMaker a b -> a -> b
J.toNullable NullMaker columnsB nullableColumnsB
nullmaker columnsB
columnsB

          Column PrimExpr
cond' = (columnsA, columnsB) -> Column PGBool
cond (columnsA
columnsA, columnsB
columnsB)
          primQueryR :: PrimQuery
primQueryR = JoinType -> PrimExpr -> PrimQuery -> PrimQuery -> PrimQuery
PQ.Join JoinType
PQ.LeftJoin PrimExpr
cond' PrimQuery
primQueryA PrimQuery
primQueryB