import logger from "../config/logger.js";
import SalesforceService from "./salesforce.service.js";

class VaClientService {
  constructor(vaClientRepository) {
    this.clientRepository = vaClientRepository;
    this.salesforceService = new SalesforceService();
  }

  async registerClient(data) {
    try {
      // Check if user already exists
      const existingUser = await this.clientRepository.findByEmail(data.userDetails.email);
      if (existingUser) {
        throw new Error("User already exists with this email");
      }

      // Sanitize and prepare data
      const clientData = this.sanitizeClientData(data);
      const response = await this.clientRepository.create(clientData);

      if(response) {
        await this.salesforceService.registerClientInSalesforce(data, response._id);
      }
      // Send data to Salesforce first
      
      return response;
    } catch (error) {
      logger.error("Client Service - registerClient error: " + error.message);
      throw error;
    }
  }

  async getClientByEmail(email) {
    try {
      const response = await this.clientRepository.findByEmail(email);
      return response;
    } catch (error) {
      logger.error("Client Service - getClientByEmail error: " + error.message);
      throw error;
    }
  }

  async getClientById(id) {
    try {
      const response = await this.clientRepository.findById(id);
      if (!response) throw new Error("Client not found");
      return response;
    } catch (error) {
      logger.error("Client Service - getClientById error: " + error.message);
      throw error;
    }
  }

  async updateClient(id, data) {
    try {
      const response = await this.clientRepository.update(id, data);
      if (!response) throw new Error("Client not found");
      return response;
    } catch (error) {
      logger.error("Client Service - updateClient error: " + error.message);
      throw error;
    }
  }

  async deleteClient(id) {
    try {
      const response = await this.clientRepository.delete(id);
      return response;
    } catch (error) {
      logger.error("Client Service - deleteClient error: " + error.message);
      throw error;
    }
  }

  // Helper method to sanitize data
  sanitizeClientData(payload) {
    const { userDetails } = payload;

    return {
      userDetails: {
        name: userDetails.name,
        email: userDetails.email.toLowerCase(),
        address: userDetails.address || null,
        city: userDetails.city || null,
        state: userDetails.state || null,
        zip: userDetails.zip || null,
        billingName: userDetails.billingName || null,
        billingAddress: userDetails.billingAddress || null,
        billingCity: userDetails.billingCity || null,
        billingState: userDetails.billingState || null,
        billingZip: userDetails.billingZip || null,
        billingEmail: userDetails.billingEmail || null,
        position: userDetails.position || null,
        signatoryName: userDetails.signatoryName || null,
        signatoryEmail: userDetails.signatoryEmail || null,
        paymentMethod: null,
        bankName: null,
        accountNumber: null,
        routingNumber: null,
        accountType: null,
        accountHolderName: null,
        cardNumber: null,
        expiryDate: null,
        securityCode: null,
        cardZip: null,
      }
    };
  }
}

export default VaClientService;