import type { Encodable } from "@automate.ax/codec"
import type { Vercel } from "@vercel/sdk"
import * as z from "zod"

/**
 * Types an official SDK-decoded object while enforcing stable public fields.
 *
 * @param schema - Runtime object shape to enforce.
 */
export function vercelObjectSchema<T extends Encodable>(
  schema: z.ZodObject,
): z.ZodType<T> {
  return z.custom<T>((value) => schema.safeParse(value).success)
}

/**
 * Types an official SDK-decoded array while enforcing stable public fields.
 *
 * @param itemSchema - Runtime shape required for every array item.
 */
export function vercelArraySchema<T extends Encodable>(
  itemSchema: z.ZodType,
): z.ZodType<T> {
  return z.custom<T>(
    (value) =>
      Array.isArray(value) &&
      value.every((item) => itemSchema.safeParse(item).success),
  )
}

const VERCEL_USER_RESPONSE_BASE_SCHEMA = z.looseObject({
  user: z.looseObject({ id: z.string(), username: z.string().optional() }),
})
const VERCEL_TEAM_BASE_SCHEMA = z.looseObject({
  id: z.string(),
  slug: z.string(),
})
const VERCEL_TEAM_PAGE_BASE_SCHEMA = z.looseObject({
  pagination: z.looseObject({}),
  teams: VERCEL_TEAM_BASE_SCHEMA.array(),
})
const VERCEL_PROJECT_BASE_SCHEMA = z.looseObject({
  id: z.string(),
  name: z.string(),
})
const VERCEL_PROJECT_PAGE_BASE_SCHEMA = z.looseObject({
  pagination: z.looseObject({}),
  projects: VERCEL_PROJECT_BASE_SCHEMA.array(),
})
const VERCEL_DEPLOYMENT_BASE_SCHEMA = z
  .looseObject({
    id: z.string().optional(),
    name: z.string(),
    uid: z.string().optional(),
    url: z.string(),
  })
  .refine(
    (deployment) => deployment.id !== undefined || deployment.uid !== undefined,
  )
const VERCEL_DEPLOYMENT_PAGE_BASE_SCHEMA = z.looseObject({
  deployments: VERCEL_DEPLOYMENT_BASE_SCHEMA.array(),
  pagination: z.looseObject({}),
})
const VERCEL_ENVIRONMENT_VARIABLE_BASE_SCHEMA = z.looseObject({
  key: z.string(),
})
const VERCEL_PROJECT_DOMAIN_BASE_SCHEMA = z.looseObject({
  name: z.string(),
  projectId: z.string(),
  verified: z.boolean(),
})
const VERCEL_PROJECT_DOMAIN_PAGE_BASE_SCHEMA = z.looseObject({
  domains: z.looseObject({ name: z.string() }).array(),
  pagination: z.looseObject({}),
})
const VERCEL_GLOBAL_CONFIG_BASE_SCHEMA = z.looseObject({
  createdAt: z.number(),
  digest: z.string(),
  id: z.string(),
  itemCount: z.number(),
  ownerId: z.string(),
  sizeInBytes: z.number(),
  slug: z.string(),
  updatedAt: z.number(),
})

/** Official Vercel current-user response. */
type VercelUserResponse = NonNullable<
  Awaited<ReturnType<Vercel["user"]["getAuthUser"]>>
> &
  Encodable

/** Official Vercel team response. */
type VercelTeam = Awaited<ReturnType<Vercel["teams"]["getTeam"]>> & Encodable

/** Official Vercel team-list response. */
type VercelTeamPage = Awaited<ReturnType<Vercel["teams"]["getTeams"]>> &
  Encodable

/** Official Vercel project response. */
type VercelProject = Awaited<ReturnType<Vercel["projects"]["getProject"]>> &
  Encodable

/** Official Vercel created-project response. */
type CreatedVercelProject = Awaited<
  ReturnType<Vercel["projects"]["createProject"]>
> &
  Encodable

/** Official Vercel updated-project response. */
type UpdatedVercelProject = Awaited<
  ReturnType<Vercel["projects"]["updateProject"]>
> &
  Encodable

/** Official Vercel project-list response. */
type VercelProjectPage = Awaited<
  ReturnType<Vercel["projects"]["getProjects"]>
> &
  Encodable

/** Official Vercel deployment response. */
type VercelDeployment = Awaited<
  ReturnType<Vercel["deployments"]["getDeployment"]>
> &
  Encodable

/** Official Vercel created-deployment response. */
type CreatedVercelDeployment = Awaited<
  ReturnType<Vercel["deployments"]["createDeployment"]>
> &
  Encodable

/** Official Vercel canceled-deployment response. */
type CanceledVercelDeployment = Awaited<
  ReturnType<Vercel["deployments"]["cancelDeployment"]>
> &
  Encodable

/** Official Vercel deployment-list response. */
type VercelDeploymentPage = Awaited<
  ReturnType<Vercel["deployments"]["getDeployments"]>
> &
  Encodable

/** Official Vercel project environment-variable list response. */
type VercelEnvironmentVariables = Awaited<
  ReturnType<Vercel["projects"]["filterProjectEnvs"]>
> &
  Encodable

/** Official Vercel created environment-variable response. */
type CreatedVercelEnvironmentVariable = Awaited<
  ReturnType<Vercel["projects"]["createProjectEnv"]>
> &
  Encodable

/** Official Vercel updated environment-variable response. */
type UpdatedVercelEnvironmentVariable = Awaited<
  ReturnType<Vercel["projects"]["editProjectEnv"]>
> &
  Encodable

/** Official Vercel removed environment-variable response. */
type RemovedVercelEnvironmentVariable = Awaited<
  ReturnType<Vercel["projects"]["removeProjectEnv"]>
> &
  Encodable

/** Official Vercel project-domain list response. */
type VercelProjectDomainPage = Awaited<
  ReturnType<Vercel["projects"]["getProjectDomains"]>
> &
  Encodable

/** Official Vercel added project-domain response. */
type VercelProjectDomain = Awaited<
  ReturnType<Vercel["projects"]["addProjectDomain"]>
> &
  Encodable

/** Official Vercel verified project-domain response. */
type VerifiedVercelProjectDomain = Awaited<
  ReturnType<Vercel["projects"]["verifyProjectDomain"]>
> &
  Encodable

/** One item from Vercel's Global Config list response. */
type VercelGlobalConfig = Awaited<
  ReturnType<Vercel["globalConfig"]["getEdgeConfigs"]>
> &
  Encodable

export const VERCEL_USER_RESPONSE_SCHEMA = z.custom<VercelUserResponse>(
  (value) => VERCEL_USER_RESPONSE_BASE_SCHEMA.safeParse(value).success,
)
export const VERCEL_TEAM_SCHEMA = z.custom<VercelTeam>(
  (value) => VERCEL_TEAM_BASE_SCHEMA.safeParse(value).success,
)
export const VERCEL_TEAM_PAGE_SCHEMA = z.custom<VercelTeamPage>(
  (value) => VERCEL_TEAM_PAGE_BASE_SCHEMA.safeParse(value).success,
)
export const VERCEL_PROJECT_SCHEMA = z.custom<VercelProject>(
  (value) => VERCEL_PROJECT_BASE_SCHEMA.safeParse(value).success,
)
export const CREATED_VERCEL_PROJECT_SCHEMA = z.custom<CreatedVercelProject>(
  (value) => VERCEL_PROJECT_BASE_SCHEMA.safeParse(value).success,
)
export const UPDATED_VERCEL_PROJECT_SCHEMA = z.custom<UpdatedVercelProject>(
  (value) => VERCEL_PROJECT_BASE_SCHEMA.safeParse(value).success,
)
export const VERCEL_PROJECT_PAGE_SCHEMA = z.custom<VercelProjectPage>(
  (value) => VERCEL_PROJECT_PAGE_BASE_SCHEMA.safeParse(value).success,
)
export const VERCEL_DEPLOYMENT_SCHEMA = z.custom<VercelDeployment>(
  (value) => VERCEL_DEPLOYMENT_BASE_SCHEMA.safeParse(value).success,
)
export const CREATED_VERCEL_DEPLOYMENT_SCHEMA =
  z.custom<CreatedVercelDeployment>(
    (value) => VERCEL_DEPLOYMENT_BASE_SCHEMA.safeParse(value).success,
  )
export const CANCELED_VERCEL_DEPLOYMENT_SCHEMA =
  z.custom<CanceledVercelDeployment>(
    (value) => VERCEL_DEPLOYMENT_BASE_SCHEMA.safeParse(value).success,
  )
export const VERCEL_DEPLOYMENT_PAGE_SCHEMA = z.custom<VercelDeploymentPage>(
  (value) => VERCEL_DEPLOYMENT_PAGE_BASE_SCHEMA.safeParse(value).success,
)
export const VERCEL_ENVIRONMENT_VARIABLES_SCHEMA =
  z.custom<VercelEnvironmentVariables>((value) => {
    if (Array.isArray(value)) {
      return value.every(
        (item) =>
          VERCEL_ENVIRONMENT_VARIABLE_BASE_SCHEMA.safeParse(item).success,
      )
    }
    return z
      .looseObject({
        envs: VERCEL_ENVIRONMENT_VARIABLE_BASE_SCHEMA.array(),
      })
      .safeParse(value).success
  })
export const CREATED_VERCEL_ENVIRONMENT_VARIABLE_SCHEMA =
  z.custom<CreatedVercelEnvironmentVariable>(
    (value) =>
      z
        .looseObject({
          created: z
            .union([
              VERCEL_ENVIRONMENT_VARIABLE_BASE_SCHEMA,
              VERCEL_ENVIRONMENT_VARIABLE_BASE_SCHEMA.array(),
            ])
            .optional(),
          failed: z.looseObject({ error: z.looseObject({}) }).array(),
        })
        .safeParse(value).success,
  )
export const UPDATED_VERCEL_ENVIRONMENT_VARIABLE_SCHEMA =
  z.custom<UpdatedVercelEnvironmentVariable>(
    (value) => VERCEL_ENVIRONMENT_VARIABLE_BASE_SCHEMA.safeParse(value).success,
  )
export const REMOVED_VERCEL_ENVIRONMENT_VARIABLE_SCHEMA =
  z.custom<RemovedVercelEnvironmentVariable>(
    (value) =>
      z.union([z.array(z.unknown()), z.looseObject({})]).safeParse(value)
        .success,
  )
export const VERCEL_PROJECT_DOMAIN_PAGE_SCHEMA =
  z.custom<VercelProjectDomainPage>(
    (value) => VERCEL_PROJECT_DOMAIN_PAGE_BASE_SCHEMA.safeParse(value).success,
  )
export const VERCEL_PROJECT_DOMAIN_SCHEMA = z.custom<VercelProjectDomain>(
  (value) => VERCEL_PROJECT_DOMAIN_BASE_SCHEMA.safeParse(value).success,
)
export const VERIFIED_VERCEL_PROJECT_DOMAIN_SCHEMA =
  z.custom<VerifiedVercelProjectDomain>(
    (value) => VERCEL_PROJECT_DOMAIN_BASE_SCHEMA.safeParse(value).success,
  )
export const VERCEL_GLOBAL_CONFIGS_SCHEMA = vercelArraySchema<
  VercelGlobalConfig[]
>(VERCEL_GLOBAL_CONFIG_BASE_SCHEMA)