import { connect } from "mongoose";
import CompanyNotificationPolicy from "../../Models/NotificationPolicies/CompanyNotificationPolicy";
import ClientNotificationPreferences from "../../Models/NotificationPolicies/ClientNotificationPreferences";
import ClientCompanyNotificationOverride from "../../Models/NotificationPolicies/ClientCompanyNotificationOverride";
import {
    ICompanyNotificationPolicy,
} from "../../Models/NotificationPolicies/CompanyNotificationPolicy.Interface";
import {
    IClientNotificationPreferences,
} from "../../Models/NotificationPolicies/ClientNotificationPreferences.Interface";
import {
    IClientCompanyNotificationOverride,
} from "../../Models/NotificationPolicies/ClientCompanyNotificationOverride.Interface";
import { NotificationChannel } from "../../Models/NotificationJobs/NotificationJobs.Interface";

export interface SessionUserParams {
    sessionUser: string;
}

export interface FindCompanyPolicyParams extends SessionUserParams {
    companyId: string;
}

export interface UpsertCompanyPolicyParams extends SessionUserParams {
    companyId: string;
    defaultChannels?: NotificationChannel[];
    timezone?: string;
    quietHours?: { from: string; to: string };
    reminderRules?: { offset: number; enabled: boolean }[];
}

export interface FindClientPreferencesParams extends SessionUserParams {
    clientId: string;
}

export interface UpsertClientPreferencesParams extends SessionUserParams {
    clientId: string;
    preferredChannels?: NotificationChannel[];
    mutedChannels?: NotificationChannel[];
}

export interface FindClientCompanyOverrideParams extends SessionUserParams {
    clientId: string;
    companyId: string;
}

export interface UpsertClientCompanyOverrideParams extends SessionUserParams {
    clientId: string;
    companyId: string;
    preferredChannels?: NotificationChannel[];
    mutedChannels?: NotificationChannel[];
}

export class NotificationPoliciesService {
    public async getCompanyPolicy(
        params: FindCompanyPolicyParams
    ): Promise<ICompanyNotificationPolicy | null> {
        await connect(`${process.env.DATABASE_CONNECTION}`);
        return CompanyNotificationPolicy.findOne(params);
    }

    public async upsertCompanyPolicy(
        params: UpsertCompanyPolicyParams
    ): Promise<ICompanyNotificationPolicy> {
        await connect(`${process.env.DATABASE_CONNECTION}`);
        const data: Partial<
            Omit<ICompanyNotificationPolicy, "id" | "companyId" | "createdAt" | "updatedAt">
        > = {};
        if (params.defaultChannels !== undefined) data.defaultChannels = params.defaultChannels;
        if (params.timezone !== undefined) data.timezone = params.timezone;
        if (params.quietHours !== undefined) data.quietHours = params.quietHours;
        if (params.reminderRules !== undefined) data.reminderRules = params.reminderRules;
        return CompanyNotificationPolicy.upsert({
            companyId: params.companyId,
            sessionUser: params.sessionUser,
            data,
        });
    }

    public async getClientPreferences(
        params: FindClientPreferencesParams
    ): Promise<IClientNotificationPreferences | null> {
        await connect(`${process.env.DATABASE_CONNECTION}`);
        return ClientNotificationPreferences.findOne({
            userId: params.clientId,
            sessionUser: params.sessionUser,
        });
    }

    public async upsertClientPreferences(
        params: UpsertClientPreferencesParams
    ): Promise<IClientNotificationPreferences> {
        await connect(`${process.env.DATABASE_CONNECTION}`);
        const data: Partial<
            Omit<IClientNotificationPreferences, "id" | "userId" | "createdAt" | "updatedAt">
        > = {};
        if (params.preferredChannels !== undefined) data.preferredChannels = params.preferredChannels;
        if (params.mutedChannels !== undefined) data.mutedChannels = params.mutedChannels;
        return ClientNotificationPreferences.upsert({
            userId: params.clientId,
            sessionUser: params.sessionUser,
            data,
        });
    }

    public async getClientCompanyOverride(
        params: FindClientCompanyOverrideParams
    ): Promise<IClientCompanyNotificationOverride | null> {
        await connect(`${process.env.DATABASE_CONNECTION}`);
        return ClientCompanyNotificationOverride.findOne(params);
    }

    public async upsertClientCompanyOverride(
        params: UpsertClientCompanyOverrideParams
    ): Promise<IClientCompanyNotificationOverride> {
        await connect(`${process.env.DATABASE_CONNECTION}`);
        const data: Partial<
            Omit<
                IClientCompanyNotificationOverride,
                "id" | "clientId" | "companyId" | "createdAt" | "updatedAt"
            >
        > = {};
        if (params.preferredChannels !== undefined) data.preferredChannels = params.preferredChannels;
        if (params.mutedChannels !== undefined) data.mutedChannels = params.mutedChannels;
        return ClientCompanyNotificationOverride.upsert({
            clientId: params.clientId,
            companyId: params.companyId,
            sessionUser: params.sessionUser,
            data,
        });
    }
}