import {DatabaseConnection} from "../Database/DatabaseConnection";
import {Model} from "../Models/Model";
import { Nullable } from "../types/Nullable";
import {DatabaseDefinition} from "../Database/DatabaseDefinition";
import {debug} from "node:util";

export class Repository<ModelType extends Model, IntermediateModelType = unknown> {
    constructor(
        protected readonly database: DatabaseConnection,
        public readonly schema: DatabaseDefinition,
    ) {}
    
    public create(instance: Partial<ModelType>): number|bigint {
        const columnNames = this.schema.columns.filter((column) => {
            return !column.primaryKey
        }).map((column) => {
            return column.name;
        });
        
        const createObject = this.convertToCreateObject(instance);
        const keys = Object.keys(createObject);
        const missingColumns = columnNames.filter((columnName) => {
            return !keys.includes(columnName);
        })
        
        if (missingColumns.length > 0) {
            throw new Error("Can't create instance, due to missing column values: " + missingColumns);
        }
        
        const sql = `INSERT INTO ${this.schema.name}(${Object.keys(createObject).join(',')}) 
                     VALUES (${Object.keys(createObject).map(() => "?").join(',')})`;
        const result = this.database.execute(sql, ...Object.values(createObject));
        return result.lastInsertRowid;
    }
    
    public getById(id: number): Nullable<ModelType> {
        const sql = `SELECT * FROM ${this.schema.name} WHERE id = ? LIMIT 1`;
        return this.convertToModelType(this.database.fetch<number, IntermediateModelType>(sql, id));
    }
    
    public delete(id: number) {
        const sql = `DELETE FROM ${this.schema.name} WHERE id = ?`;
        return this.database.execute(sql, id);
    }
    
    protected convertToModelType(intermediateModel: IntermediateModelType | undefined): ModelType {
        return intermediateModel as unknown as ModelType;
    }
    protected convertToCreateObject(instance: Partial<ModelType>): object {
        return instance;
    }
}