import { Database, type Changes } from "bun:sqlite";
import _ from "lodash";
import { Ok, Err, Result, None, Some, Option } from "ts-results-es";
import { z } from "zod";
import { fun } from "./common";

const db = new Database("lab.sqlite", { strict: true })
initDB(db);

// Error Type
export const BOARD_ERR_WRONG_TYPE = "Wrong type"
export const BOARD_ERR_NO_BOARDS = "No such Boards"
export const BOARD_ERR_ID_CONFLICT = "ID conflict"
export const BOARD_ERR_NAME_CONFLICT = "Name conflict in one room"

export type BoardErrorType = (
  typeof BOARD_ERR_WRONG_TYPE |
  typeof BOARD_ERR_NO_BOARDS |
  typeof BOARD_ERR_ID_CONFLICT |
  typeof BOARD_ERR_NAME_CONFLICT
)

const boardSchema = z.object({
  id: z.number().nonnegative(),
  name: z.string(),
  room: z.string(),
  ipv4: z.string().ip({ version: "v4" }),
  ipv6: z.string().ip({ version: "v6" }),
  port: z.number().nonnegative().lte(65535),
  cmdID: z.number().nonnegative()
}).partial({
  ipv6: true,
  cmdID: true
})

export type Board = z.infer<typeof boardSchema>
export type BoardColumn = keyof Board

export function isBoard(obj: any): obj is Board {
  return boardSchema.safeParse(obj).success
}

export function isBoardArray(obj: any): obj is Array<Board> {
  return boardSchema.array().safeParse(obj).success
}

export function isBoardColumn(obj: any): obj is BoardColumn {
  return boardSchema.keyof().safeParse(obj).success
}

const userSchema = z.object({
  id: z.number().nonnegative(),
  name: z.string(),
  password: z.string(),
  boardID: z.number(),
}).partial({
  boardID: true,
})

export type User = z.infer<typeof userSchema>
export type UserColumn = keyof User

export function isUser(obj: any): obj is User {
  return userSchema.safeParse(obj).success
}

export function isUserArray(obj: any): obj is Array<User> {
  return userSchema.array().safeParse(obj).success
}

export function isUserColumn(obj: any): obj is UserColumn {
  return userSchema.keyof().safeParse(obj).success
}

function initDB(db: Database) {
  const tables = allTables()

  if (!tables.includes("Users")) {
    db.query(`
      CREATE TABLE Users(
        id         INT PRIMARY KEY   NOT NULL,
        name       TEXT              NOT NULL,
        password   TEXT              NOT NULL
      );
    `).run();
  }

  if (!tables.includes("Boards"))
    db.query(`
      CREATE TABLE Boards(
        id         INT PRIMARY KEY   NOT NULL,
        name       TEXT              NOT NULL,
        room       TEXT              NOT NULL,
        ipv4       CHAR(16)          NOT NULL,
        ipv6       CHAR(46)                  ,
        port       INT               NOT NULL
      )
    `).run();
}

export function allTables(): Array<string> {
  const query = db.query(`SELECT name FROM sqlite_master WHERE type='table'`)
  var tables = new Array()
  // Flaten array
  for (const item of query.values()) {
    tables.push(item[0])
  }

  query.finalize()
  return tables
}

export function tableColumnName(table: string): Array<string> {
  const query = db.query(`PRAGMA table_info(${table})`)

  var columnName = new Array()
  for (const column of query.values()) {
    columnName.push(column[1])
  }

  return columnName
}

export namespace BoardTable {

  export function add(board: Board): Result<Changes, BoardErrorType> {
    if (!isBoard(board)) {
      return new Err(BOARD_ERR_WRONG_TYPE)
    }

    // Ensure no id conflict
    if (board.id == 0) {
      const cnt = countAll()
      board.id = cnt + 1
    } else {
      const retID = includes(board.id)
      if (retID.isOk()) {
        if (retID.value) return new Err(BOARD_ERR_ID_CONFLICT)
      } else {
        return new Err(BOARD_ERR_WRONG_TYPE)
      }
    }

    // Ensure no name conflict in the same room
    {
      const retName = includes(board.name, board.room)
      if (retName.isOk()) {
        if (retName.value) {
          return new Err(BOARD_ERR_NAME_CONFLICT)
        }
      } else {
        return new Err("Wrong type")
      }
    }

    const query = db.query(`
    INSERT INTO Boards VALUES 
    (${board.id},
    '${board.name}',
    '${board.room}',
    '${board.ipv4}',
    '${_.isUndefined(board.ipv6) ? "NULL" : board.ipv6}',
    ${board.port});
  `)

    return Ok(query.run())
  }

  export function addFromArray(array: Array<Board>)
    : Result<Array<Changes>, BoardErrorType> {

    let arrayChanges: Array<Changes> = []
    for (const item of array) {
      const ret = add(item)
      if (ret.isErr()) {
        return ret
      } else {
        arrayChanges.push(ret.value)
      }
    }

    return new Ok(arrayChanges)
  }

  export function all(): Option<Array<Board>> {
    const query = db.query(`SELECT * FROM Boards`)
    const ret = query.all()
    query.finalize()

    if (isBoardArray(ret)) {
      return Some(ret)
    } else {
      return None
    }
  }

  export function countAll(): number {
    const query = db.query(`SELECT COUNT(*) FROM Boards`)
    return query.values()[0][0] as number
  }

  export function countByName(name: string): number {
    const query = db.query(`SELECT * FROM Boards WHERE name=${name}`)
    return query.values()[0][0] as number
  }

  export function countByRoom(room: string): number {
    const query = db.query(`SELECT * FROM Boards WHERE room=${room}`)
    return query.values()[0][0] as number
  }

  export function remove(name: string, room: string): Result<Board, BoardErrorType>
  export function remove(id: number): Result<Board, BoardErrorType>
  export function remove(board: Board): Result<Board, BoardErrorType>
  export function remove(arg1: any, arg2?: any): Result<Board, BoardErrorType> {
    let retBoard
    let condition: string
    if (isBoard(arg1)) {
      retBoard = _.cloneDeep(arg1)
      condition = `id=${arg1.id}`

    } else if (_.isNumber(arg1)) {
      retBoard = find(arg1)
      if (retBoard.isOk() && retBoard.value.isSome()) {
        retBoard = _.cloneDeep(retBoard.value.value)
        condition = `id=${arg1}`
      } else {
        return new Err(BOARD_ERR_WRONG_TYPE)
      }

    } else if (_.isString(arg1) && _.isString(arg2)) {
      retBoard = find(arg1, arg2)
      if (retBoard.isOk() && retBoard.value.isSome()) {
        retBoard = _.cloneDeep(retBoard.value.value)
        condition = `name=${arg1}`
      } else {
        return new Err(BOARD_ERR_NO_BOARDS)
      }

    } else {
      return new Err(BOARD_ERR_WRONG_TYPE)
    }

    const query = db.query(`DELETE FROM Boards WHERE ${condition}`)
    query.run()

    return new Ok(retBoard)
  }

  export function removeAll(): Option<Array<Board>> {
    const array = all()
    const query = db.query(`DELETE FROM Boards`)
    query.run()


    if (array.isSome()) {
      return new Some(array.value)
    } else {
      return None
    }
  }

  export function removeByCondition(condition: string): Result<Array<Board>, BoardErrorType> {
    const rsArr = findByCondition(condition)
    if (rsArr.isNone()) {
      return new Err(BOARD_ERR_NO_BOARDS)
    }

    const query = db.query(`DELETE FROM Boards WHERE ${condition}`)
    query.run()

    return new Ok(rsArr.value)
  }

  export function removeByValue(columnName: string, val: string | Array<string>)
    : Result<Array<Board>, BoardErrorType> {

    if (!isBoardColumn(columnName)) {
      return new Err(BOARD_ERR_WRONG_TYPE)
    }

    let condition: string
    if (_.isString(val)) {
      const retCond = fun.sqlConditionFromString(columnName, val, "OR")
      if (retCond.isSome()) {
        condition = retCond.value
      } else {
        return new Err(BOARD_ERR_WRONG_TYPE)
      }
    } else if (fun.isStringArray(val)) {
      const retCond = fun.sqlConditionFromArray(columnName, val, "OR")
      if (retCond.isSome()) {
        condition = retCond.value
      } else {
        return new Err(BOARD_ERR_WRONG_TYPE)
      }
    } else {
      return new Err(BOARD_ERR_WRONG_TYPE)
    }

    return removeByCondition(condition)
  }

  export function removeByName(name: string | Array<string>)
    : Result<Array<Board>, BoardErrorType> {
    return removeByValue("name", name)
  }

  export function removeByRoom(room: string | Array<string>)
    : Result<Array<Board>, BoardErrorType> {

    return removeByValue("room", room)
  }

  export function rooms(): Option<Array<string>> {
    const query = db.query(`SELECT DISTINCT room FROM Boards`)
    let rooms: Array<string> = []
    const retVal = query.values()

    if (retVal.length > 0) {
      for (const item of retVal) {
        rooms.push(item[0] as string)
      }
      return new Some(rooms)
    } else {
      return None
    }
  }


  export function find(name: string, room: string): Result<Option<Board>, BoardErrorType>
  export function find(id: number): Result<Option<Board>, BoardErrorType>
  export function find(arg1: any, arg2?: any): Result<Option<Board>, BoardErrorType> {
    let condition: string
    if (_.isNumber(arg1)) {
      condition = `id=${arg1}`

    } else if (_.isString(arg1) && _.isString(arg2)) {
      condition = `name='${arg1}' AND room='${arg2}'`

    } else {
      return new Err(BOARD_ERR_WRONG_TYPE)
    }

    const query = db.query(`SELECT * FROM Boards WHERE ${condition}`)

    const spRet = boardSchema.safeParse(query.get())

    if (spRet.success) {
      return new Ok(Some(spRet.data))
    } else {
      return new Ok(None)
    }
  }

  export function findByName(name: string | Array<string>): Result<Option<Array<Board>>, BoardErrorType> {
    let condition: string
    if (_.isString(name)) {
      const retCond = fun.sqlConditionFromString("name", name, "OR")
      if (retCond.isSome()) {
        condition = retCond.value
      } else {
        return new Err(BOARD_ERR_WRONG_TYPE)
      }
    } else if (fun.isStringArray(name)) {
      const retCond = fun.sqlConditionFromArray("name", name, "OR")
      if (retCond.isSome()) {
        condition = retCond.value
      } else {
        return new Err(BOARD_ERR_WRONG_TYPE)
      }
    } else {
      return new Err(BOARD_ERR_WRONG_TYPE)
    }

    return new Ok(findByCondition(condition))
  }

  export function findByCondition(condition: string): Option<Array<Board>> {
    const query = db.query(`SELECT * FROM Boards WHERE ${condition}`)
    const ret = query.all()
    if (isBoardArray(ret)) {
      return new Some(ret)
    } else {
      return None
    }
  }

  export function findByValue(columnName: string, val: string | Array<string>)
    : Result<Option<Array<Board>>, BoardErrorType> {

    if (!isBoardColumn(columnName)) {
      return new Err(BOARD_ERR_WRONG_TYPE)
    }

    let condition: string
    if (_.isString(val)) {
      const retCond = fun.sqlConditionFromString(columnName, val, "OR")
      if (retCond.isSome()) {
        condition = retCond.value
      } else {
        return new Err(BOARD_ERR_WRONG_TYPE)
      }
    } else if (fun.isStringArray(val)) {
      const retCond = fun.sqlConditionFromArray(columnName, val, "OR")
      if (retCond.isSome()) {
        condition = retCond.value
      } else {
        return new Err(BOARD_ERR_WRONG_TYPE)
      }
    } else {
      return new Err(BOARD_ERR_WRONG_TYPE)
    }

    return new Ok(findByCondition(condition))
  }

  export function includes(name: string, room?: string): Result<boolean, BoardErrorType>
  export function includes(id: number): Result<boolean, BoardErrorType>
  export function includes(arg1: any, arg2?: any): Result<boolean, BoardErrorType> {
    let condition: string
    if (_.isUndefined(arg2)) {
      if (_.isNumber(arg1)) {
        condition = `id=${arg1}`

      } else if (_.isString(arg1)) {
        condition = `name='${arg1}'`

      } else {
        return new Err(BOARD_ERR_WRONG_TYPE)
      }
    } else {
      if (_.isString(arg1) && _.isString(arg2)) {
        condition = `name='${arg1} AND room=${arg2}'`
      } else {
        return new Err(BOARD_ERR_WRONG_TYPE)
      }
    }

    const query = db.query(`SELECT COUNT(*) FROM Boards WHERE ${condition}`)
    const num = query.values()[0][0] as number

    return new Ok(num > 0 ? true : false)
  }

}

export namespace UserTable {

  export function countAll(): number {
    const query = db.query(`SELECT COUNT(*) FROM Users`)
    return query.values()[0][0] as number
  }


  export function find(id: number): Result<Option<User>, "Wrong Type">
  export function find(name: string): Result<Option<User>, "Wrong Type">
  export function find(arg: any): Result<Option<User>, "Wrong Type"> {
    let condition: string
    if (_.isNumber(arg)) {
      condition = `id=${arg}`
    } else if (_.isString(arg)) {
      condition = `name=${arg}`
    } else {
      return new Err("Wrong Type")
    }

    const query = db.query(`SELECT * FROM Users WHERE name='${arg}'`)

    const spRet = userSchema.safeParse(query.get())

    if (spRet.success) {
      return new Ok(Some(spRet.data))
    } else {
      return new Ok(None)
    }
  }

}