import fs from "node:fs/promises";
import { Database, SQLiteError } from "bun:sqlite";

import type { UserEntry, RecordEntry, EstimatesEntry } from "$lib/db_types";
import { calculateDuration, parseDate, toInt, isTimeValidHHMM } from "$lib/util";

import Logs from "$lib/server/log"

const DATABASES_PATH: string = (process.env.APP_USER_DATA_PATH ?? ".") + "/databases/";
const USER_DATABASE_PATH: string = DATABASES_PATH + "users.sqlite";

const CHECK_QUERY: string = 
	"SELECT * FROM sqlite_master;";

const USER_DATABASE_SETUP: string[] = [
	"PRAGMA foreign_keys = ON;",

	`CREATE TABLE IF NOT EXISTS users (
		id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, 
		name TEXT,
		gender TEXT,
		address TEXT,
		username TEXT,
		password TEXT,
		permissions INTEGER DEFAULT 0,
		created DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL
	);`,

	`CREATE TABLE refresh_tokens (
		id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
		user_id INTEGER NOT NULL,
		token TEXT UNIQUE,
		expiry_date DATETIME,
		created DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
		FOREIGN KEY(user_id) REFERENCES users(id)
	);`,

	/*`CREATE TABLE session_tokens (
		id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
		user_id INTEGER NOT NULL,
		create_token_id INTEGER NOT NULL,
		token TEXT UNIQUE,
		expiry_date DATETIME,
		created DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
		FOREIGN KEY(user_id) REFERENCES users(id),
		FOREIGN KEY(create_token_id) REFERENCES access_tokens(id)
	);`,*/
];

const USER_DATABASE_ADD_USER: string = 
	"INSERT INTO users (name, gender, address, username, password) VALUES ($name, $gender, $address, $username, $password);";

const USER_DATABASE_GET_ALL_USER: string =
	"SELECT id, username, name FROM users;";

const USER_DATABASE_GET_USER_BY_ID: string =
	"SELECT * FROM users WHERE id = $id;"

const USER_DATABASE_GET_USER_BY_NAME: string =
	"SELECT * FROM users WHERE username = $username;"

const USER_DATABASE_EMPTY: string = 
	"SELECT EXISTS (SELECT 1 FROM users);"

const USER_DATABASE_UPDATE_PASSWORD: string = 
	"UPDATE users SET password=$password WHERE id=$id;"

/*const USER_DATABASE_ADD_ACCESS_TOKEN: string = 
	"INSERT INTO access_tokens (user_id, token, expiry_date) VALUES ($user_id, $token, $expiry_date);"

const USER_DATABASE_REMOVE_ACCESS_TOKEN: string = 
	"UPDATE access_tokens SET expiry_date = NULL WHERE token = $token;"*/

const ENTRY_DATABASE_SETUP: string[] = [
	"PRAGMA foreign_keys = ON;",

	"CREATE TABLE meta (key TEXT PRIMARY KEY NOT NULL, value NUMBER);",
	"INSERT INTO meta(key, value) VALUES ('triggerActive', 1)",

	`CREATE TABLE records (
		id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
		date VARCHAR(10),
		start VARCHAR(5), 
		end VARCHAR(5), 
		comment TEXT, 
		created DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL 
	);`,

	`CREATE TABLE records_history (
		id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
		record_id INTEGER NOT NULL,
		date VARCHAR(10),
		start VARCHAR(5),
		end V<F52>ARCHAR(5),
		comment TEXT,
		modified DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
		FOREIGN KEY(record_id) REFERENCES records(id)
	);`,

	`CREATE TRIGGER records_update_history
		BEFORE UPDATE ON records
		WHEN (SELECT value FROM meta WHERE key = 'triggerActive') = 1
	BEGIN
		INSERT INTO records_history(record_id, date, start, end, comment) VALUES (OLD.id, OLD.date, OLD.start, OLD.end, OLD.comment);
	END;`,
	
	`CREATE TRIGGER records_delete_history
		BEFORE DELETE ON records
		WHEN (SELECT value FROM meta WHERE key = 'triggerActive') = 1
	BEGIN	
		INSERT INTO records_history(record_id, date, start, end, comment) VALUES (OLD.id, OLD.date, OLD.start, OLD.end, OLD.comment);
	END;`,

	`CREATE TABLE estimates (
		id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
		year INTEGER NOT NULL,
		quarter INTEGER NOT NULL,
		estimate_0 REAL,
		estimate_1 REAL,
		estimate_2 REAL,
		created DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
		UNIQUE(year, quarter)
	);`,

	`CREATE TABLE estimates_history (
		id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
		estimate_id INTEGER NOT NULL,
		year INTEGER NOT NULL,
		quarter INTEGER NOT NULL,
		estimate_0 REAL NOT NULL,
		estimate_1 REAL NOT NULL,
		estimate_2 REAL NOT NULL,
		modified DATETIME DEFAULT NULL,
		FOREIGN KEY(estimate_id) REFERENCES estimates(id)
	);`,

	`CREATE TRIGGER estimates_update_history
		BEFORE UPDATE ON estimates
		WHEN (SELECT value FROM meta WHERE key = 'triggerActive') = 1
	BEGIN
		INSERT INTO estimates_history(estimate_id, year, quarter, estimate_0, estimate_1, estimate_2) VALUES (OLD.id, OLD.year, OLD.quarter, OLD.estimate_0, OLD.estimate_1, OLD.estimate_2);
	END;`,
	
	`CREATE TRIGGER estimates_delete_history
		BEFORE DELETE ON estimates
		WHEN (SELECT value FROM meta WHERE key = 'triggerActive') = 1
	BEGIN	
		INSERT INTO estimates_history(estimate_id, year, quarter, estimate_0, estimate_1, estimate_2) VALUES (OLD.id, OLD.year, OLD.quarter, OLD.estimate_0, OLD.estimate_1, OLD.estimate_2);
	END;`,
]

const ENTRY_DATABASE_GET_MONTHS: string =
	"SELECT DISTINCT SUBSTR(date, 7, 4) as year, SUBSTR(date, 4, 2) as month FROM records ORDER BY year DESC, month DESC;"

const ENTRY_DATABASE_GET_ENTRY_BY_ID: string =
	"SELECT * FROM records WHERE id = $id;"

const ENTRY_DATABASE_GET_ENTRIES_IN_MONTH: string =
	"SELECT * FROM records WHERE SUBSTR(date, 7, 4) = $year AND SUBSTR(date, 4, 2) = $month ORDER BY SUBSTR(date, 1, 2);"

const ENTRY_DATABASE_GET_ENTRIES: string =
	"SELECT * FROM records ORDER BY SUBSTR(date, 7, 4) DESC, SUBSTR(date, 4, 2) DESC, SUBSTR(date, 1, 2) DESC;"

const ENTRY_DATABASE_ADD_ENTRY: string = 
	"INSERT INTO records(date, start, end, comment) VALUES ($date, $start, $end, $comment);"

const ENTRY_DATABASE_EDIT_ENTRY: string = 
	"UPDATE records SET date = $date, start = $start, end = $end, comment = $comment WHERE id = $id;";

const ENTRY_DATABASE_REMOVE_ENTRY: string = 
	"DELETE FROM records WHERE id = $id;";

const ESTIMATES_DATABASE_GET_ALL: string =
	"SELECT * FROM estimates ORDER BY year DESC, quarter DESC;"

const ESTIMATES_DATABASE_GET_QUARTERS: string = 
	"SELECT year, quarter FROM estimates;"

const ESTIMATES_DATABASE_GET_QUART: string = 
	"SELECT estimate_0, estimate_1, estimate_2 FROM estimates WHERE year = $year AND quarter = $quarter;"

const ESTIMATES_DATABASE_INSERT: string =
	"INSERT INTO estimates(year, quarter, estimate_0, estimate_1, estimate_2) VALUES ($year, $quarter, $estimate_0, $estimate_1, $estimate_2);"

export class User {
	id: number;
	gender: string;
	name: string;
	address: string;
	username: string;
	password: string;
	permissions: number;
	created: string;

	private _database: Database;

	constructor(user: UserEntry, db: Database) {
		this.id = user.id;
		this.gender = user.gender;
		this.name = user.name;
		this.address = user.address;
		this.username = user.username;
		this.password = user.password;
		this.permissions = user.permissions;
		this.created = user.created;
		this._database = db;
	}

	toUserEntry(): UserEntry {
		return {
			id: this.id,
			gender: this.gender,
			name: this.name,
			address: this.address,
			username: this.username,
			password: this.password,
			permissions: this.permissions,
			created: this.created,
		}
	}

	get_months(): { year: string, month: string }[] {
		const query = this._database.query(ENTRY_DATABASE_GET_MONTHS);
		const res = query.all();

		const ret = res.map((v) => { return { year: toInt(v.year), month: toInt(v.month) }})

		return ret;
	}

	get_quarters(): { year: number, quarter: number }[] {
		const query = this._database.query(ESTIMATES_DATABASE_GET_QUARTERS)
		const res = query.all();

		return res;
	}

	get_hr_sum(year: number, month: number): number {
		const months = this.get_entries_by_month(year, month);

		let sum = 0;
		months.forEach((record) => { sum += calculateDuration(record.start, record.end) })
		return sum;
	}

	get_entries(): Entry[] {	
		const query = this._database.query(ENTRY_DATABASE_GET_ENTRIES);
		const res = query.all()

		return res;
	}

	get_entries_by_month(year: number, month: number): RecordEntry[] {
		if (!(month > 0 && month < 13)) {
			return [];
		}

		const query = this._database.query(ENTRY_DATABASE_GET_ENTRIES_IN_MONTH);
		const res = query.all({ year: year.toString(), month: month.toString().padStart(2, '0') });

		return res;
	}

	get_entry(id: number): RecordEntry {
		const query = this._database.query(ENTRY_DATABASE_GET_ENTRY_BY_ID);
		const res = query.get({ id: id });

		return res;
	}

	insert_entry(date: string, start: string, end: string, comment: string | null) {
		
		if (parseDate(date) == null || !isTimeValidHHMM(start) || !isTimeValidHHMM(end)) {
			return false;
		}

		const query = this._database.query(ENTRY_DATABASE_ADD_ENTRY);
		const res = query.run({ date: date, start: start, end: end, comment: comment });
		
		return res.changes == 1;
	}

	update_entry(id: number, ndate: string, nstart: string, nend: string, ncomment: string): boolean {

		if (isNaN(id) || parseDate(ndate) == null || !isTimeValidHHMM(nstart) || !isTimeValidHHMM(nend)) {
			return false;
		}

		const query = this._database.query(ENTRY_DATABASE_EDIT_ENTRY);
		const res = query.run({ id: id, date: ndate, start: nstart, end: nend, comment: ncomment });

		return res.changes > 1;
	}

	remove_entry(id: number): boolean {
		if (isNaN(id)) {
			return false;
		}

		const query = this._database.query(ENTRY_DATABASE_REMOVE_ENTRY);
		const res = query.run({ id: id });

		return res.changes > 1;
	}

	get_estimates(): Array<EstimatesEntry> {
		const query = this._database.query(ESTIMATES_DATABASE_GET_ALL);
		const res = query.all();

		return res;
	}
	
	get_estimate(year: number, quarter: number): EstimatesEntry {
		const query = this._database.query(ESTIMATES_DATABASE_GET_QUART);
		const res = query.get({ year: year, quarter: quarter });

		return res;
	}

	get_estimate_by_month(year: number, month: number): number {
		const query = this._database.query(ESTIMATES_DATABASE_GET_QUART);
		const res = query.all({ year: year, quarter: Math.floor(month / 4 + 1) });

		return res[0]?.[`estimate_${month % 3}`] ?? NaN;
	}

	insert_estimate(year: number, quarter: number, estimate_0: number, estimate_1: number, estimate_2: number) {
		if (isNaN(year) || isNaN(quarter) || quarter < 1 || quarter > 4 || isNaN(estimate_0) || isNaN(estimate_1) || isNaN(estimate_2)) {
			return null;
		}

		const query = this._database.query(ESTIMATES_DATABASE_INSERT);
		const res = query.run({ year: year, quarter: quarter, estimate_0: estimate_0, estimate_1: estimate_1, estimate_2: estimate_2 });
		console.log(res)

		return res.changes > 1;
	}
}


let user_database: Database;


function is_db_initialized(db: Database): boolean {
	try {
		
		let res = db.query(CHECK_QUERY).get();

		return res != null;
	} catch (exception) {
		if (!(exception instanceof SQLiteError)) {
			throw exception;
		}

		console.log(exception);

		return false;
	}
}

function get_user_db_name(user: UserEntry) {
	return DATABASES_PATH + "user-" + user.id + ".sqlite"
}

function setup_db(db: Database, setup_queries: string[]) {
   setup_queries.forEach((q) => { /*console.log(q);*/ db.query(q).run(); });
}

export async function init_db() {

	const stdout = await fs.mkdir(DATABASES_PATH, { recursive: true });

	user_database = new Database(USER_DATABASE_PATH, { strict: true, create: true });

	if (!is_db_initialized(user_database)) {	
		setup_db(user_database, USER_DATABASE_SETUP);
	}

}

export function close_db() {
	if (user_database) {
		user_database.close();
	}
}

export async function create_user(user: { name: string, gender: string, address: string, username: string, password: string }): Promise<boolean> {
	
	user.password = await Bun.password.hash(user.password, { algorithm: "bcrypt", cost: 11});

	try {
		const statement = user_database.query(USER_DATABASE_ADD_USER);
		const result = statement.run(user);

		return result.changes == 1;
	} catch (e) {
		console.log(e);
		if (e instanceof SQLiteError) {
			return false;
		}

		throw e;
	}
}
export function get_all_user(): { id: number, username: string, name: string }[] {

	try {
		const query = user_database.prepare(USER_DATABASE_GET_ALL_USER)
		const user = query.all() as { id: number, username: string, name: string }[]
	
		return user
	} catch (e) {
		throw e
	}
}

export function get_user_entry_by_id(id: number): UserEntry | null {

	try {
		const query = user_database.query(USER_DATABASE_GET_USER_BY_ID)
		const user = query.get({ id: id }) as UserEntry | null;

		return user
	} catch (e) {
		Logs.db.error(`Encountered exception when retrievieng user ${id} from database: ${e.message}`)
	}
	
	return null
}

export function get_user_by_name(username: string): User | null {
	
	try {
		const query = user_database.prepare(USER_DATABASE_GET_USER_BY_NAME);
		const user = query.get({ username: username }) as UserEntry | null ;

		if (!user) {
			return null;
		}

		fs.mkdir(DATABASES_PATH, { recursive: true });
		
		let userdb = new Database(get_user_db_name(user), { create: true, strict: true });

		if (!is_db_initialized(userdb)) {
			setup_db(userdb, ENTRY_DATABASE_SETUP);
		}

		return new User(user, userdb);
	} catch (exception) {
		if (!(exception instanceof SQLiteError)) {
			throw exception;
		}
	}

	return null;
}

export function do_users_exist(): any {	
	const answer = user_database.prepare(USER_DATABASE_EMPTY).get();
	
	// sqlite trims the first "SELECT " and ";" from the query string
	return (answer as any)?.[USER_DATABASE_EMPTY.slice(7, -1)];
}

export function updateUser(data: {id: number, gender?: string, name?: string, address?: string, username?: string, permissions?: number }) {
	let changed: Array<string> = []
	if (data.gender) changed.push("gender=$gender")
	if (data.name) changed.push("name=$name")
	if (data.address) changed.push("address=$address")
	if (data.username) changed.push("username=$username")
	if (data.permissions) changed.push("permissions=$permissions")
	
	const update_query = "UPDATE users SET " + changed.join(", ") + " WHERE id=$id;"

	const query = user_database.prepare(update_query)
	const result = query.run(data)

	return get_user_by_name(data?.name ?? "")	// GET USER BY lastRowId from result
}

export function update_user_password(user_id: number, password: string) {
	const query = user_database.prepare(USER_DATABASE_UPDATE_PASSWORD)
	const result = query.run({ password: password, id: user_id })

	return result.changes > 0
}