import type { Abode } from "../types/Abode.js";
import type { ApikeyPermissions, ClientApikey } from "../types/Apikey.js";
import type { Resident, ResidentFlags } from "../types/Resident.js";
import type { ClientUser, PartialUser, UserFlags } from "../types/User.js";

export function dateToSqlite(date: string) {
  return new Date(date).getTime() / 1000;
}
export function sqliteToDate(date: string) {
  return new Date(date.replace(" ", "T") + "Z").toISOString();
}

export function uuidToSqlite(uuid: string) {
  return Buffer.from(uuid.replaceAll("-", ""), "hex");
}
export function sqliteToUuid(uuid: Buffer | Uint8Array) {
  const hex = (uuid instanceof Buffer ? uuid : Buffer.from(uuid)).toString(
    "hex"
  );
  return [
    hex.slice(0, 8),
    hex.slice(8, 12),
    hex.slice(12, 16),
    hex.slice(16, 20),
    hex.slice(20),
  ].join("-");
}

const defaultUserFlags: UserFlags = {};
export function sqliteToUserFlags(flags: string): UserFlags {
  const parsed = JSON.parse(flags);
  const out = { ...defaultUserFlags };

  if (typeof parsed !== "object" || !parsed || Array.isArray(parsed))
    return out;

  if (parsed.admin === true) out.admin = true;
  return out;
}

export function sqliteToPartialUser(user: {
  uid: Buffer | Uint8Array;
  name: string;
  flags: string;
  created_at: string;
  updated_at: string;
}): PartialUser {
  return {
    uid: sqliteToUuid(user.uid),
    name: user.name,
    flags: sqliteToUserFlags(user.flags),
    created_at: sqliteToDate(user.created_at),
    updated_at: sqliteToDate(user.updated_at),
  };
}
export function sqliteToClientUser(user: {
  uid: Buffer | Uint8Array;
  email: string;
  name: string;
  flags: string;
  created_at: string;
  updated_at: string;
}): ClientUser {
  return {
    ...sqliteToPartialUser(user),
    email: user.email,
  };
}

export function sqliteToAbode(abode: {
  aid: Buffer | Uint8Array;
  name: string;
  created_at: string;
  created_by: Buffer | Uint8Array | null;
  updated_at: string;
  updated_by: Buffer | Uint8Array | null;
}): Abode {
  return {
    aid: sqliteToUuid(abode.aid),
    name: abode.name,
    created_at: sqliteToDate(abode.created_at),
    created_by: abode.created_by && sqliteToUuid(abode.created_by),
    updated_at: sqliteToDate(abode.updated_at),
    updated_by: abode.updated_by && sqliteToUuid(abode.updated_by),
  };
}

const defaultResidentFlags: ResidentFlags = {};
export function sqliteToResidentFlags(flags: string): ResidentFlags {
  const parsed = JSON.parse(flags);
  const out = { ...defaultResidentFlags };

  if (typeof parsed !== "object" || !parsed || Array.isArray(parsed))
    return out;

  if (parsed.admin === true) out.admin = true;
  return out;
}

export function sqliteToResident(resident: {
  uid: Buffer | Uint8Array;
  aid: Buffer | Uint8Array;
  flags: string;
  created_at: string;
  created_by: Buffer | Uint8Array | null;
  updated_at: string;
  updated_by: Buffer | Uint8Array | null;
}): Resident {
  return {
    uid: sqliteToUuid(resident.uid),
    aid: sqliteToUuid(resident.aid),
    flags: sqliteToResidentFlags(resident.flags),
    created_at: sqliteToDate(resident.created_at),
    created_by: resident.created_by && sqliteToUuid(resident.created_by),
    updated_at: sqliteToDate(resident.updated_at),
    updated_by: resident.updated_by && sqliteToUuid(resident.updated_by),
  };
}

const defaultApikeyPermissions: ApikeyPermissions = {};
export function sqliteToApikeyPermissions(
  permissions: string
): ApikeyPermissions {
  const parsed = JSON.parse(permissions);
  const out = { ...defaultApikeyPermissions };

  if (typeof parsed !== "object" || !parsed || Array.isArray(parsed))
    return out;

  if (parsed.admin === true) out.admin = true;
  if (parsed.all === true) out.all = true;
  for (const key of ["users", "residents", "abodes"] as const) {
    if (parsed[key] === "r" || parsed[key] === "rw") out[key] = parsed[key];
  }
  for (const key of ["restrict_users", "restrict_abodes"] as const) {
    if (
      Array.isArray(parsed[key]) &&
      parsed[key].every((x) => typeof x === "string")
    ) {
      out[key] = parsed[key];
    }
  }
  return out;
}

export function sqliteToClientApikey(apikey: {
  uid: Buffer | Uint8Array;
  kid: Buffer | Uint8Array;
  name: string;
  permissions: string;
  created_at: string;
  expires_at: string | null;
}): ClientApikey {
  return {
    uid: sqliteToUuid(apikey.uid),
    kid: sqliteToUuid(apikey.kid),
    name: apikey.name,
    permissions: sqliteToApikeyPermissions(apikey.permissions),
    created_at: sqliteToDate(apikey.created_at),
    expires_at: apikey.expires_at ? sqliteToDate(apikey.expires_at) : null,
  };
}