import {Repository} from "./Repository";
import {GroupModel} from "../Models/GroupModel";
import Groups, {DBGroup} from "../Database/tables/Groups";
import {DatabaseConnection} from "../Database/DatabaseConnection";
import {CacheType, CacheTypeReducer, Guild, GuildMember, GuildMemberRoleManager} from "discord.js";
import {Nullable} from "../types/Nullable";

export class GroupRepository extends Repository<GroupModel, DBGroup> {

    constructor(
        protected readonly database: DatabaseConnection,
    ) {
        super(
            database,
            Groups
        );
        
    }
    
    public findGroupByName(name: string): Nullable<GroupModel> {
        const result = this.database.fetch<string, DBGroup>(
            `SELECT * FROM groups WHERE name = ? LIMIT 1`,
            name
        )
        
        if (!result) {
            return undefined;
        }
        
        return this.convertToModelType(result);
    }
    
    public findGroupsByRoles(server: string, roleIds: string[]): GroupModel[] {
        const template = roleIds.map(roleId => '?').join(',');
        
        const dbResult = this.database.fetchAll<number[], DBGroup>(`
        SELECT * FROM groups WHERE server = ? AND role IN (${template})
        `,
            server,
            ...roleIds)
        
        
        return dbResult.map((result) => this.convertToModelType(result));
    }

    public findGroupsByMember(member: GuildMember) {
        if (!member) {
            throw new Error("Can't find member for guild: none given");
        } 
        
        return this.findGroupsByRoles(member.guild.id, [...member.roles.cache.keys()])
    }
    
    protected convertToModelType(intermediateModel: DBGroup | undefined): GroupModel {
        if (!intermediateModel) {
            throw new Error("No intermediate model provided");
        }
        
        return {
            id: intermediateModel.id,
            name: intermediateModel.name,
            leader: {
                server: intermediateModel.server,
                memberid: intermediateModel.leader
            },
            role: {
                server: intermediateModel.server,
                roleid: intermediateModel.role
            }
        }
    }

    protected convertToCreateObject(instance: Partial<GroupModel>): object {
        return {
            name: instance.name ?? '',
            server: instance.role?.server ?? null,
            leader: instance.leader?.memberid ?? null,
            role: instance.role?.roleid ?? null,
        }
    }

}