{-# LANGUAGE OverloadedStrings #-}

module ActionParserTest (tests) where

import qualified Convex.Action.Parser as Action
import qualified Convex.Parser as Parser
import qualified Convex.Schema.Parser as Schema
import qualified Data.Map as Map
import Test.HUnit
import Text.Parsec (runParserT)

-- A dedicated test runner for unification tests that first parses a schema.
runSchemaUnificationTest ::
  String ->
  String ->
  String ->
  [Action.ConvexFunction] ->
  Test
runSchemaUnificationTest testName schemaString actionString expected =
  testName ~: TestCase $ do
    -- First, parse the schema to get the constants.
    schemaResult <- Schema.parseSchema schemaString
    case schemaResult of
      Left err -> assertFailure ("Schema parser failed: " ++ show err)
      Right parsedSchemaFile -> do
        let initialState = Schema.ParserState {Schema.psConstants = Schema.parsedConstants parsedSchemaFile}
        -- Now, parse the action file with the constants from the schema.
        actionResult <- runParserT (Action.parseActionFile "testPath") initialState "(test)" actionString
        case actionResult of
          Left err -> assertFailure ("Action parser failed: " ++ show err)
          Right funcs ->
            let project =
                  Parser.ParsedProject
                    { Parser.ppSchema = Schema.parsedSchema parsedSchemaFile,
                      Parser.ppConstants = Schema.parsedConstants parsedSchemaFile,
                      Parser.ppFunctions = funcs
                    }
                unifiedProject = Parser.runUnificationPass project
             in Parser.ppFunctions unifiedProject @?= expected

-- A dedicated test runner for unification tests.
runUnificationTest ::
  String ->
  String ->
  Map.Map String Schema.ConvexType ->
  String ->
  [Action.ConvexFunction] ->
  Test
runUnificationTest testName path constants input expected =
  testName ~: TestCase $ do
    let initialState = Schema.ParserState {Schema.psConstants = constants}
    result <- runParserT (Action.parseActionFile path) initialState "(test)" input
    case result of
      Left err -> assertFailure ("Parser failed: " ++ show err)
      Right funcs ->
        let project =
              Parser.ParsedProject
                { Parser.ppSchema = Schema.Schema {Schema.getTables = []},
                  Parser.ppConstants = constants,
                  Parser.ppFunctions = funcs
                }
            unifiedProject = Parser.runUnificationPass project
         in Parser.ppFunctions unifiedProject @?= expected

tests :: Test
tests =
  "Action Definition Parser"
    ~: test
      [ runActionTest "parses createProject mutation" "test/api" sampleCreateProject expectedCreateProject,
        runActionTest "ignores internal actions" "test/api" sampleInternalAction [],
        runActionTest "parses public query with complex return" "functions/users" samplePublicGetOrgs expectedPublicGetOrgs,
        runActionTest "parses public action with optional args" "functions/stripe" samplePublicAction expectedPublicAction,
        runActionTest "parses internal action with external type as VAny" "functions/stripe" sampleStripeSubscriptionAction expectedStripeSubscriptionAction,
        runActionTest "parses public action with external type" "functions/stripe" sampleStripeCheckoutAction sampleStripeCheckoutActionExpected,
        runActionTest "parses public action with external type as VAny" "functions/stripe" sampleStripeSubscriptionActionPublic expectedStripeSubscriptionActionPublic,
        runActionTest "parses createAsset mutation with complex args" "functions/assets" sampleCreateAssetAction expectedCreateAssetAction,
        runUnificationTest
          "unifies function return with named doc"
          "functions/users"
          userProfileConstants
          sampleGetUserAction
          expectedGetUserAction,
        runSchemaUnificationTest
          "unifies function return with table doc"
          sampleSchemaWithUserTable
          sampleGetUserTableAction
          expectedGetUserTableAction
      ]
  where
    runActionTest testName path input expected =
      testName ~: TestCase $ do
        result <- runParserT (Action.parseActionFile path) Schema.initialState "(test)" input
        case result of
          Left err -> assertFailure ("Parser failed: " ++ show err)
          Right funcs -> funcs @?= expected

sampleCreateProject :: String
sampleCreateProject =
  unlines
    [ "export declare const createProject: import(\"convex/server\").RegisteredMutation<\"public\", {",
      "  project_name?: string;",
      "  tenant_id: import(\"convex/values\").GenericId<\"tenants\">;",
      "}, Promise<import(\"convex/values\").GenericId<\"projects\">>>;"
    ]

expectedCreateProject :: [Action.ConvexFunction]
expectedCreateProject =
  [ Action.ConvexFunction
      { Action.funcName = "createProject",
        Action.funcPath = "test/api",
        Action.funcType = Action.Mutation,
        Action.funcArgs =
          [ ("project_name", Schema.VOptional Schema.VString),
            ("tenant_id", Schema.VId "tenants")
          ],
        Action.funcReturn = Schema.VId "projects"
      }
  ]

sampleInternalAction :: String
sampleInternalAction = "export declare const sendOtp: import(\"convex/server\").RegisteredAction<\"internal\", { email: string; }, Promise<{ success: boolean; }>>;"

samplePublicGetOrgs :: String
samplePublicGetOrgs =
  unlines
    [ "export declare const getOrgs: import(\"convex/server\").RegisteredQuery<\"public\", {}, Promise<{",
      "  name: string;",
      "  _id: import(\"convex/values\").GenericId<\"memberships\">;",
      "  _creationTime: number;",
      "  user_id: import(\"convex/values\").GenericId<\"users\">;",
      "  tenant_id: import(\"convex/values\").GenericId<\"tenants\">;",
      "  roles: (\"viewer\" | \"user\" | \"admin\")[];",
      "}[]>>;"
    ]

expectedPublicGetOrgs :: [Action.ConvexFunction]
expectedPublicGetOrgs =
  [ Action.ConvexFunction
      { Action.funcName = "getOrgs",
        Action.funcPath = "functions/users",
        Action.funcType = Action.Query,
        Action.funcArgs = [],
        Action.funcReturn =
          Schema.VArray
            ( Schema.VObject
                [ ("name", Schema.VString),
                  ("_id", Schema.VId "memberships"),
                  ("_creationTime", Schema.VNumber),
                  ("user_id", Schema.VId "users"),
                  ("tenant_id", Schema.VId "tenants"),
                  ( "roles",
                    Schema.VArray
                      ( Schema.VUnion
                          [ Schema.VLiteral "viewer",
                            Schema.VLiteral "user",
                            Schema.VLiteral "admin"
                          ]
                      )
                  )
                ]
            )
      }
  ]

samplePublicAction :: String
samplePublicAction =
  unlines
    [ "export declare const createCheckoutSession: import(\"convex/server\").RegisteredAction<\"public\", {",
      "    next_url?: string;",
      "    tenant_id: import(\"convex/values\").GenericId<\"tenants\">;",
      "    price_id: string;",
      "}, Promise<string>>;"
    ]

expectedPublicAction :: [Action.ConvexFunction]
expectedPublicAction =
  [ Action.ConvexFunction
      { Action.funcName = "createCheckoutSession",
        Action.funcPath = "functions/stripe",
        Action.funcType = Action.Action,
        Action.funcArgs =
          [ ("next_url", Schema.VOptional Schema.VString),
            ("tenant_id", Schema.VId "tenants"),
            ("price_id", Schema.VString)
          ],
        Action.funcReturn = Schema.VString
      }
  ]

sampleStripeSubscriptionAction :: String
sampleStripeSubscriptionAction = "export declare const stripeSubscription: import(\"convex/server\").RegisteredAction<\"internal\", { subscription_id: string; }, Promise<Stripe.Subscription>>;"

expectedStripeSubscriptionAction :: [Action.ConvexFunction]
expectedStripeSubscriptionAction = []

sampleStripeSubscriptionActionPublic :: String
sampleStripeSubscriptionActionPublic =
  unlines
    [ "export declare const stripeSubscription: import(\"convex/server\").RegisteredAction<\"public\", {",
      "    subscription_id: string;",
      "}, Promise<Stripe.Subscription>>;"
    ]

-- Even though the return type is an external type, it should still parse correctly.
expectedStripeSubscriptionActionPublic :: [Action.ConvexFunction]
expectedStripeSubscriptionActionPublic =
  [ Action.ConvexFunction
      { Action.funcName = "stripeSubscription",
        Action.funcPath = "functions/stripe",
        Action.funcType = Action.Action,
        Action.funcArgs = [("subscription_id", Schema.VString)],
        Action.funcReturn = Schema.VAny -- External type, parsed as VAny
      }
  ]

sampleStripeCheckoutAction :: String
sampleStripeCheckoutAction =
  unlines
    [ "export declare const createCheckoutSession: import(\"convex/server\").RegisteredAction<\"public\", {",
      "    next_url?: string;",
      "    tenant_id: import(\"convex/values\").GenericId<\"tenants\">;",
      "    price_id: string;",
      "}, Promise<string>>;"
    ]

sampleStripeCheckoutActionExpected :: [Action.ConvexFunction]
sampleStripeCheckoutActionExpected =
  [ Action.ConvexFunction
      { Action.funcName = "createCheckoutSession",
        Action.funcPath = "functions/stripe",
        Action.funcType = Action.Action,
        Action.funcArgs =
          [ ("next_url", Schema.VOptional Schema.VString),
            ("tenant_id", Schema.VId "tenants"),
            ("price_id", Schema.VString)
          ],
        Action.funcReturn = Schema.VString
      }
  ]

sampleCreateAssetAction :: String
sampleCreateAssetAction =
  unlines
    [ "export declare const createAsset: import(\"convex/server\").RegisteredMutation<\"public\", {",
      "    projectId: import(\"convex/values\").GenericId<\"projects\">;",
      "    linkMetadata: {",
      "        summary: ArrayBuffer;",
      "        sample_rate: number;",
      "        length: number;",
      "        linkable_uri: string;",
      "    };",
      "}, Promise<import(\"convex/values\").GenericId<\"assets\">>>;"
    ]

expectedCreateAssetAction :: [Action.ConvexFunction]
expectedCreateAssetAction =
  [ Action.ConvexFunction
      { Action.funcName = "createAsset",
        Action.funcPath = "functions/assets",
        Action.funcType = Action.Mutation,
        Action.funcArgs =
          [ ("projectId", Schema.VId "projects"),
            ( "linkMetadata",
              Schema.VObject
                [ ("summary", Schema.VBytes),
                  ("sample_rate", Schema.VNumber),
                  ("length", Schema.VNumber),
                  ("linkable_uri", Schema.VString)
                ]
            )
          ],
        Action.funcReturn = Schema.VId "assets"
      }
  ]

-- Test case for structural unification of a function's return type.
userProfileConstants :: Map.Map String Schema.ConvexType
userProfileConstants =
  Map.fromList
    [ ("UserProfile", userProfileType),
      ("Address", addressType)
    ]
  where
    addressType =
      Schema.VObject
        [ ("street", Schema.VString),
          ("city", Schema.VString)
        ]
    userProfileType =
      Schema.VObject
        [ ("name", Schema.VString),
          ("address", Schema.VReference "Address")
        ]

sampleGetUserAction :: String
sampleGetUserAction =
  unlines
    [ "export declare const getUser: import(\"convex/server\").RegisteredQuery<\"public\", {}, Promise<{",
      "  name: string;",
      "  address: {",
      "    street: string;",
      "    city: string;",
      "  };",
      "}>>;"
    ]

expectedGetUserAction :: [Action.ConvexFunction]
expectedGetUserAction =
  [ Action.ConvexFunction
      { Action.funcName = "getUser",
        Action.funcPath = "functions/users",
        Action.funcType = Action.Query,
        Action.funcArgs = [],
        Action.funcReturn = Schema.VReference "UserProfile" -- Should be unified
      }
  ]

-- Test case for unification against a table doc.
sampleSchemaWithUserTable :: String
sampleSchemaWithUserTable =
  unlines
    [ "import { defineSchema, defineTable } from \"convex/server\";",
      "import { v } from \"convex/values\";",
      "",
      "export default defineSchema({",
      "  users: defineTable({",
      "    name: v.string(),",
      "    email: v.string()",
      "  })",
      "});"
    ]

sampleGetUserTableAction :: String
sampleGetUserTableAction =
  unlines
    [ "export declare const getUser: import(\"convex/server\").RegisteredQuery<\"public\", {}, Promise<{",
      "  _id: import(\"convex/values\").GenericId<\"users\">;",
      "  _creationTime: number;",
      "  name: string;",
      "  email: string;",
      "}>>;"
    ]

expectedGetUserTableAction :: [Action.ConvexFunction]
expectedGetUserTableAction =
  [ Action.ConvexFunction
      { Action.funcName = "getUser",
        Action.funcPath = "testPath",
        Action.funcType = Action.Query,
        Action.funcArgs = [],
        Action.funcReturn = Schema.VReference "UsersDoc" -- Should be unified
      }
  ]

sampleSchemaWithAssetsTable :: String
sampleSchemaWithAssetsTable =
  unlines
    [ "import { defineSchema, defineTable } from \"convex/server\";",
      "import { v } from \"convex/values\";",
      "",
      "export default defineSchema({",
      "  projects: defineTable({",
      "    name: v.string()",
      "  }),",
      "  assets: defineTable({",
      "    project_id: v.id(\"projects\"),",
      "    asset_name: v.string(),",
      "    asset_essence_mtime: v.number(),",
      "    link_metadata: v.object({",
      "      sample_rate: v.number(),",
      "      summary: v.bytes(),",
      "      length: v.number()",
      "    })",
      "  })",
      "});"
    ]

sampleGetAssetsAction :: String
sampleGetAssetsAction =
  unlines
    [ "export declare const getAssets: import(\"convex/server\").RegisteredQuery<\"public\", {",
      "  project_id: import(\"convex/values\").Id<\"projects\">;",
      "  secret: string;",
      "}, Promise<Array<{",
      "  _id: import(\"convex/values\").Id<\"assets\">;",
      "  _creationTime: number;",
      "  project_id: import(\"convex/values\").Id<\"projects\">;",
      "  asset_name: string;",
      "  asset_essence_mtime: number;",
      "  link_metadata: {",
      "    summary: Uint8Array;",
      "    sample_rate: number;",
      "    length: number;",
      "  };",
      "}>>>;"
    ]

expectedGetAssetsAction :: [Action.ConvexFunction]
expectedGetAssetsAction =
  [ Action.ConvexFunction
      { Action.funcName = "getAssets",
        Action.funcPath = "testPath",
        Action.funcType = Action.Query,
        Action.funcArgs =
          [ ("project_id", Schema.VId "projects"),
            ("secret", Schema.VString)
          ],
        Action.funcReturn = Schema.VArray (Schema.VReference "AssetsDoc")
      }
  ]