import {Repository} from "./Repository";
import {GroupModel} from "../Models/GroupModel";
import Groups, {DBGroup} from "../tables/Groups";
import {DatabaseConnection} from "../DatabaseConnection";
import {GuildMember, UserFlagsBitField} from "discord.js";
import {Nullable} from "../../types/Nullable";
import {PlaydateRepository} from "./PlaydateRepository";
import {Container} from "../../Container/Container";

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, onlyLeader: boolean = false) {
    if (!member) {
      throw new Error("Can't find member for guild: none given");
    }

    const groups = this.findGroupsByRoles(member.guild.id, [...member.roles.cache.keys()])

    if (!onlyLeader) {
      return groups;
    }

    return groups.filter((group: GroupModel) => {
      return group.leader.memberid === member.id;
    })
  }
  
  public isMemberInGroup(member: Nullable<GuildMember>, group: GroupModel): boolean 
  {
    if (!member) {
      throw new Error("Can't find member for guild: none given");
    }

    const groups = this.findGroupsByRoles(member.guild.id, [...member.roles.cache.keys()])
    
    return groups.some((dbGroup) => {
      return group.id === dbGroup.id;
    })
  }

  public deleteGroup(group: GroupModel): void {
    this.delete(group.id);

    const repo = Container.get<PlaydateRepository>(PlaydateRepository.name);
    const playdates = repo.findFromGroup(group, true)
    playdates.forEach((playdate) => {
      repo.delete(playdate.id);
    })
  }

  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,
    }
  }

}