import { getClientWithToken } from '../apollo/client';
import * as GQL from '../types';
import { BaseService } from './base';
import { type VariablesOf } from '@graphql-typed-document-node/core';

export class CustomersService extends BaseService {
  async addMasters(variables: VariablesOf<typeof GQL.UpdateCustomerDocument>) {
    const newMasterIds = variables.data.masters;

    const { mutate, query } = await getClientWithToken();
    const getMastersResult = await query({
      query: GQL.GetMastersDocument,
      variables,
    });

    const existingMasterIds = getMastersResult?.data?.customers
      ?.at(0)
      ?.masters.map((x) => x?.documentId);

    const newMastersIds = [...new Set([...(existingMasterIds || []), ...(newMasterIds || [])])];

    const mutationResult = await mutate({
      mutation: GQL.UpdateCustomerDocument,
      variables: {
        data: { masters: newMastersIds },
        documentId: variables.documentId,
      },
    });

    const error = mutationResult.errors?.at(0);
    if (error) throw new Error(error.message);

    return mutationResult.data;
  }

  async createCustomer(variables: VariablesOf<typeof GQL.CreateCustomerDocument>) {
    const { mutate } = await getClientWithToken();

    const mutationResult = await mutate({
      mutation: GQL.CreateCustomerDocument,
      variables,
    });

    const error = mutationResult.errors?.at(0);
    if (error) throw new Error(error.message);

    return mutationResult.data;
  }

  async getCustomer(variables: VariablesOf<typeof GQL.GetCustomerDocument>) {
    const { query } = await getClientWithToken();

    const result = await query({
      query: GQL.GetCustomerDocument,
      variables,
    });

    if (result.error) throw new Error(result.error.message);

    const customer = result.data.customers.at(0);

    return { customer };
  }

  async getClients(variables?: VariablesOf<typeof GQL.GetClientsDocument>) {
    const { query } = await getClientWithToken();

    const result = await query({
      query: GQL.GetClientsDocument,
      variables: {
        telegramId: variables?.telegramId || this.customer.telegramId,
      },
    });

    if (result.error) throw new Error(result.error.message);

    return result.data;
  }

  async getMasters(variables?: VariablesOf<typeof GQL.GetMastersDocument>) {
    const { query } = await getClientWithToken();

    const result = await query({
      query: GQL.GetMastersDocument,
      variables: {
        telegramId: variables?.telegramId || this.customer.telegramId,
      },
    });

    if (result.error) throw new Error(result.error.message);

    return result.data;
  }

  async updateCustomer(
    variables: Omit<VariablesOf<typeof GQL.UpdateCustomerDocument>, 'documentId'>,
  ) {
    const { customer } = await this.getCustomer(this.customer);

    if (!customer) throw new Error('Customer not found');
    const { mutate } = await getClientWithToken();

    const mutationResult = await mutate({
      mutation: GQL.UpdateCustomerDocument,
      variables: {
        data: variables.data,
        documentId: customer.documentId,
      },
    });

    const error = mutationResult.errors?.at(0);
    if (error) throw new Error(error.message);

    return mutationResult.data;
  }
}