import type {
  DBQueryConfigOrderByCallback,
  DBQueryConfigOrderByObject,
  SQL,
  TableFilterCommons,
} from "../orm/index.ts"
import { and, lt, gt, desc, asc } from "../orm/index.ts"

import type { AnyTableSchema, TableSchemaToSelect } from "./infer.ts"
import type { AnyPgColumn } from "./pgcore.ts"

export type Cursor = string | null
export interface WithCursorBasedPaginationOptions {
  limit: number
  cursor: Cursor
}
export interface WithCursorBasedPaginationResult {
  nextCursor: Cursor
  totalCount: number
}

interface OrderByOption<Key> {
  key: Key
  order: "asc" | "desc"
}
export interface EncodeCursorOptions<Data> {
  data: Data
  orderBy: Array<OrderByOption<keyof Data>>
}
export type EncodeCursorResult = string
export const encodeCursor = <Model>(options: EncodeCursorOptions<Model>): EncodeCursorResult => {
  const { data, orderBy } = options
  const encoded = orderBy
    .map((item) => {
      const { key } = item
      if (data[key] === undefined) {
        throw new Error(`data[${String(key)}] is undefined`)
      }
      return data[key]
    })
    .map((value) => {
      if (value instanceof Date) {
        return `Date(${value.getTime()})`
      }
      return String(value)
    })
    .join(":")
  return btoa(encoded)
}

export interface DecodeCursorOptions<Data, Key extends keyof Data = keyof Data> {
  dataForType: Data
  cursor: Cursor
  orderBy: Array<OrderByOption<Key>>
}
export type DecodedCursor<Data, Key extends keyof Data = keyof Data> = {
  [K in Key]: Data[K] extends Date ? Date : Data[K]
}
export type DecodeCursorResult<Data, Key extends keyof Data = keyof Data> = DecodedCursor<
  Data,
  Key
> | null
export const decodeCursor = <Data, Key extends keyof Data = keyof Data>(
  options: DecodeCursorOptions<Data, Key>,
): DecodeCursorResult<Data, Key> => {
  const { cursor, orderBy } = options
  if (cursor === null) {
    return null
  }
  const decoded = atob(cursor)
    .split(":")
    .map((value) => {
      if (value.startsWith("Date(")) {
        return new Date(Number.parseInt(value.slice(5, -1), 10))
      }
      return value
    })
    .reduce((acc, value, index) => {
      const key = orderBy[index]!.key
      return { ...acc, [key]: value }
    }, {})
  return decoded as DecodedCursor<Data, Key>
}

export interface GetNextCursorOptions<Data> {
  list: Data[]
  limit: number
  encodeOptions: Omit<EncodeCursorOptions<Data>, "data">
}
export type GetNextCursorResult = Cursor
export const getNextCursor = <Data>(options: GetNextCursorOptions<Data>): GetNextCursorResult => {
  const { list, limit, encodeOptions } = options
  if (list.length === 0) {
    return null
  }
  if (list.length < limit) {
    return null
  }
  const lastData = list.at(-1)!
  const cursor = encodeCursor({
    data: lastData,
    ...encodeOptions,
  })
  return cursor
}

export interface BuildWhereSqlOptions<
  TableSchema extends AnyTableSchema,
  Key extends keyof TableSchemaToSelect<TableSchema>,
> {
  tableSchema: TableSchema
  orderBy: Array<OrderByOption<Key>>
  decodeCursorResult: DecodeCursorResult<TableSchemaToSelect<TableSchema>, Key>
}
export type BuildWhereSqlResult = SQL | undefined
export const buildWhereSql = <
  TableSchema extends AnyTableSchema,
  Key extends keyof TableSchemaToSelect<TableSchema>,
>(
  options: BuildWhereSqlOptions<TableSchema, Key>,
): BuildWhereSqlResult => {
  const { tableSchema, decodeCursorResult, orderBy } = options
  if (decodeCursorResult === null) {
    return undefined
  }
  if (orderBy.length === 0) {
    return undefined
  }
  const conditionSqlList = orderBy.map((item) => {
    const { key, order } = item
    if (order === "asc") {
      return gt(
        tableSchema[key as keyof TableSchema] as unknown as AnyPgColumn,
        decodeCursorResult[key],
      )
    }
    if (order === "desc") {
      return lt(
        tableSchema[key as keyof TableSchema] as unknown as AnyPgColumn,
        decodeCursorResult[key],
      )
    }
    throw new Error(`Invalid order: ${String(order)}`)
  })
  return and(...conditionSqlList)
}

export interface BuildWhereQueryOptions<
  TableSchema extends AnyTableSchema,
  Key extends keyof TableSchemaToSelect<TableSchema>,
> {
  tableSchemaForType: TableSchema
  orderBy: Array<OrderByOption<Key>>
  decodeCursorResult: DecodeCursorResult<TableSchemaToSelect<TableSchema>, Key>
}
/**
 * @description 此处只支持表内字段的条件构建，不支持关联表字段的条件构建。
 * 这样做的原因是为了保持类型参数简单且一致，若引入关联表字段条件构建，
 * 则需要引入完整的 Relations 类型作为类型参数（截至 drizzle-orm 1.0.0-beta）。
 */
export type BuildWhereQueryResult<TableSchema extends AnyTableSchema> =
  TableFilterCommons<TableSchema>
export const buildWhereQuery = <
  TableSchema extends AnyTableSchema,
  Key extends keyof TableSchemaToSelect<TableSchema>,
>(
  options: BuildWhereQueryOptions<TableSchema, Key>,
): BuildWhereQueryResult<TableSchema> => {
  const { decodeCursorResult, orderBy } = options
  if (decodeCursorResult === null) {
    return {}
  }
  if (orderBy.length === 0) {
    return {}
  }
  const conditionList = orderBy.map((item) => {
    const { key, order } = item
    if (order === "asc") {
      return {
        [key]: {
          gt: decodeCursorResult[key],
        },
      }
    }
    if (order === "desc") {
      return {
        [key]: {
          lt: decodeCursorResult[key],
        },
      }
    }
    throw new Error(`Invalid order: ${String(order)}`)
  })
  if (conditionList.length === 1) {
    return conditionList[0]!
  }
  return {
    AND: conditionList,
  } as BuildWhereQueryResult<TableSchema>
}

export interface BuildOrderBySql<
  TableSchema extends AnyTableSchema,
  Key extends keyof TableSchemaToSelect<TableSchema>,
> {
  tableSchema: TableSchema
  orderBy: Array<OrderByOption<Key>>
}
export type BuildOrderBySqlResult<TableSchema extends AnyTableSchema> =
  DBQueryConfigOrderByCallback<TableSchema>
export const buildOrderBySql = <
  TableSchema extends AnyTableSchema,
  Key extends keyof TableSchemaToSelect<TableSchema>,
>(
  options: BuildOrderBySql<TableSchema, Key>,
): BuildOrderBySqlResult<TableSchema> => {
  const { tableSchema, orderBy } = options
  const sqlList = orderBy.map((item) => {
    const { key, order } = item
    if (order === "asc") {
      return asc(tableSchema[key as keyof TableSchema] as unknown as AnyPgColumn)
    }
    if (order === "desc") {
      return desc(tableSchema[key as keyof TableSchema] as unknown as AnyPgColumn)
    }
    throw new Error(`Invalid order: ${String(order)}`)
  })
  return () => sqlList
}
export interface BuildOrderByQueryOptions<
  TableSchema extends AnyTableSchema,
  Key extends keyof TableSchemaToSelect<TableSchema>,
> {
  tableSchemaForType: TableSchema
  orderBy: Array<OrderByOption<Key>>
}
export type BuildOrderByQueryResult<TableSchema extends AnyTableSchema> =
  DBQueryConfigOrderByObject<TableSchema["_"]["columns"]>
export const buildOrderByQuery = <
  TableSchema extends AnyTableSchema,
  Key extends keyof TableSchemaToSelect<TableSchema>,
>(
  options: BuildOrderByQueryOptions<TableSchema, Key>,
): BuildOrderByQueryResult<TableSchema> => {
  const { orderBy } = options
  const orderByObject = orderBy.reduce<BuildOrderByQueryResult<TableSchema>>((acc, item) => {
    const { key, order } = item
    return Object.assign(acc, { [key]: order })
  }, {})
  return orderByObject
}

export interface BuildCursorBasedPaginationOptions<
  TableSchema extends AnyTableSchema,
  Key extends keyof TableSchemaToSelect<TableSchema>,
> {
  tableSchema: TableSchema
  orderBy: Array<OrderByOption<Key>>
  cursor: Cursor
  limit: number
}
export interface BuildCursorBasedPaginationResult<
  TableSchema extends AnyTableSchema,
  Key extends keyof TableSchemaToSelect<TableSchema>,
> {
  decodeCursorResult: DecodeCursorResult<TableSchemaToSelect<TableSchema>, Key>
  whereSql: BuildWhereSqlResult
  whereSqlAnd: (sql: BuildWhereSqlResult) => BuildWhereQueryResult<TableSchema>
  whereQuery: BuildWhereQueryResult<TableSchema>
  whereQueryAnd: (query: BuildWhereQueryResult<TableSchema>) => BuildWhereQueryResult<TableSchema>
  orderBySql: BuildOrderBySqlResult<TableSchema>
  orderByQuery: BuildOrderByQueryResult<TableSchema>
  limit: number
  getNextCursor: (list: Array<TableSchemaToSelect<TableSchema>>) => Cursor
}
export const buildCursorBasedPagination = <
  TableSchema extends AnyTableSchema,
  Key extends keyof TableSchemaToSelect<TableSchema>,
>(
  options: BuildCursorBasedPaginationOptions<TableSchema, Key>,
): BuildCursorBasedPaginationResult<TableSchema, Key> => {
  const { tableSchema, orderBy, limit, cursor } = options

  type Data = TableSchemaToSelect<TableSchema>

  const decodeCursorResult = decodeCursor({
    dataForType: {} as Data,
    cursor,
    orderBy,
  })

  const whereSql = buildWhereSql({
    tableSchema,
    decodeCursorResult,
    orderBy,
  })

  const whereSqlAnd = (sql: BuildWhereSqlResult): BuildWhereQueryResult<TableSchema> => {
    return {
      RAW: and(whereSql, sql),
    }
  }

  const whereQuery = buildWhereQuery({
    tableSchemaForType: tableSchema,
    decodeCursorResult,
    orderBy,
  })

  const whereQueryAnd = (
    query: BuildWhereQueryResult<TableSchema>,
  ): BuildWhereQueryResult<TableSchema> => {
    return {
      AND: [whereQuery, query],
    } as BuildWhereQueryResult<TableSchema>
  }

  const orderBySql = buildOrderBySql({
    tableSchema,
    orderBy,
  })

  const orderByQuery = buildOrderByQuery({
    tableSchemaForType: tableSchema,
    orderBy,
  })

  const _getNextCursor = (list: Data[]): Cursor => {
    return getNextCursor({
      list,
      limit,
      encodeOptions: {
        orderBy,
      },
    })
  }

  return {
    decodeCursorResult,
    whereSql,
    whereSqlAnd,
    whereQuery,
    whereQueryAnd,
    orderBySql,
    orderByQuery,
    limit,
    getNextCursor: _getNextCursor,
  }
}