Centralized_Reporting_Backend/src/services/integration/integrationService.js

const ZohoClient = require('../../integrations/zoho/client');

class IntegrationService {
  constructor(userId) {
    this.userId = userId;
    this.clients = {
      zoho: new ZohoClient(userId)
    };
  }

  async getData(provider, service, resource, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }

    const method = this.getMethodName(service, resource);
   
    if (!client[method]) {
      throw new Error(`Resource ${resource} not supported for ${provider} ${service}`);
    }

    // Handle special cases that require additional parameters
    if (method === 'getTasks' && service === 'projects' && params.projectId) {
      return await client.getProjectTasks(params.projectId, params);
    }

    // Handle getAllProjectTasks for projects tasks without projectId
    if (method === 'getTasks' && service === 'projects' && !params.projectId) {
      return await client.getAllProjectTasks(params);
    }

    // Handle CRM tasks (no special parameters needed)
    if (method === 'getTasks' && service === 'crm') {
      return await client[method](params);
    }

    return await client[method](params);
  }

  getMethodName(service, resource) {
    const resourceMap = {
      'leads': 'Leads',
      'contacts': 'Contacts', 
      'deals': 'Deals',
      'employees': 'Employees',
      'projects': 'Projects',
      'tasks': 'Tasks',
      'timesheets': 'Timesheets'
    };

    const resourceName = resourceMap[resource] || resource;
    return `get${resourceName}`;
  }

  async getAvailableServices(provider) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    return client.getAvailableServices();
  }

  async getAvailableResources(provider, service) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    return client.getAvailableResources(service);
  }

  async getPortals(provider) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Portals are only available for Zoho provider');
    }
    return await client.getPortals();
  }

  async getAllProjects(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('All projects are only available for Zoho provider');
    }
    return await client.getAllProjects(params);
  }

  async getAllProjectTasks(provider, portalId, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('All project tasks are only available for Zoho provider');
    }
    return await client.getAllProjectTasks(portalId, params);
  }

  async getAllProjectTaskLists(provider, portalId, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('All project task lists are only available for Zoho provider');
    }
    return await client.getAllProjectTaskLists(portalId, params);
  }

  async getAllProjectIssues(provider, portalId, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('All project issues are only available for Zoho provider');
    }
    return await client.getAllProjectIssues(portalId, params);
  }

  async getAllProjectPhases(provider, portalId, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('All project phases are only available for Zoho provider');
    }
    return await client.getAllProjectPhases(portalId, params);
  }

  async getSalesOrders(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Sales Orders are only available for Zoho provider');
    }
    return await client.getSalesOrders(params);
  }

  async getPurchaseOrders(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Purchase Orders are only available for Zoho provider');
    }
    return await client.getPurchaseOrders(params);
  }

  async getInvoices(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Invoices are only available for Zoho provider');
    }
    return await client.getInvoices(params);
  }
}

module.exports = IntegrationService;