va-tracker-middleware/src/controllers/client/vaClient.controller.js

import VaClientRepository from "../../repository/vaClient.repository.js";
import VaClientService from "../../services/vaClient.service.js";
import logger from "../../config/logger.js";
import jwt from "jsonwebtoken";

const vaClientService = new VaClientService(new VaClientRepository());


async function va_register_client(req, res) {
  logger.info("ClientController - Register Client Hit ...");
  
  try {
    const payload = req.body || {};
    const { userDetails } = payload;
    if (!userDetails || !userDetails.email || !userDetails.name) {
      return res.status(400).json({ 
        success: false, 
        message: "Missing required fields: name and email are required" 
      });
    }

    const created = await vaClientService.registerClient(payload);

    logger.info(`ClientController - Client registered successfully: ${userDetails.email}`);
    return res.status(201).json({ 
      success: true, 
      data: created,
      message: "Client registered successfully" 
    });
  } catch (error) {
    logger.error(`ClientController - Register error: ${error.message}`);
    
    if (error.message === "User already exists with this email") {
      return res.status(409).json({ 
        success: false, 
        message: error.message 
      });
    }

    if (error.message.includes("Salesforce API is unreachable")) {
      return res.status(503).json({ 
        success: false, 
        message: "Salesforce service is currently unavailable. Please try again later." 
      });
    }

    return res.status(500).json({ 
      success: false, 
      message: "Internal Server Error" 
    });
  }
}

// Additional controller methods can be added here
async function get_client_profile(req, res) {
  try {
    const email = req.body.clientEmail;
    const client = await vaClientService.getClientByEmail(email);
    
    if (!client) {
      return res.status(404).json({ 
        success: false, 
        message: "Client not found" 
      });
    }

    return res.status(200).json({ 
      success: true, 
      data: client 
    });
  } catch (error) {
    logger.error(`ClientController - Get client error: ${error.message}`);
    return res.status(500).json({ 
      success: false, 
      message: "Internal Server Error" 
    });
  }
}

async function delete_client(req, res) {
  logger.info("ClientController - Delete Client Hit ...");
  
  try {
    const { clientId } = req.params;

    if (!clientId) {
      return res.status(400).json({ 
        success: false, 
        message: "Client ID is required" 
      });
    }

    const deletedClient = await vaClientService.deleteClient(clientId);

    if (!deletedClient) {
      return res.status(404).json({ 
        success: false, 
        message: "Client not found" 
      });
    }

    logger.info(`ClientController - Client deleted successfully: ${clientId}`);
    return res.status(200).json({ 
      success: true, 
      message: "Client deleted successfully",
      data: {
        clientId: clientId,
        clientName: deletedClient.userDetails?.name || 'Unknown Client',
        deletedAt: new Date().toISOString()
      }
    });
  } catch (error) {
    logger.error(`ClientController - Delete error: ${error.message}`);
    
    if (error.message === "Client not found") {
      return res.status(404).json({ 
        success: false, 
        message: error.message 
      });
    }

    return res.status(500).json({ 
      success: false, 
      message: "Internal Server Error" 
    });
  }
}

async function update_client(req, res) {
  logger.info("ClientController - Update Client Hit ...");
  
  try {
    const { clientId } = req.params;
    const payload = req.body || {};
    const { userDetails } = payload;

    if (!clientId) {
      return res.status(400).json({ 
        success: false, 
        message: "Client ID is required" 
      });
    }

    if (!userDetails) {
      return res.status(400).json({ 
        success: false, 
        message: "Missing userDetails in request body" 
      });
    }

    const updatedClient = await vaClientService.updateClient(clientId, payload);

    logger.info(`ClientController - Client updated successfully: ${clientId}`);
    return res.status(200).json({ 
      success: true, 
      message: "Client updated successfully",
      data: updatedClient
    });
  } catch (error) {
    logger.error(`ClientController - Update error: ${error.message}`);
    
    if (error.message === "Client not found") {
      return res.status(404).json({ 
        success: false, 
        message: error.message 
      });
    }

    if (error.message.includes("Email already exists")) {
      return res.status(409).json({ 
        success: false, 
        message: error.message 
      });
    }

    return res.status(500).json({ 
      success: false, 
      message: "Internal Server Error" 
    });
  }
}

async function get_client_dashboard_profile(req, res) {
  try {
    const accessToken = req.headers.token;        
    
    if (!accessToken) {
      return res.status(401).json({ success: false, message: "Missing token" });
    }

    const decoded = jwt.verify(accessToken, process.env.JWT_SECRET_ACCESS_TOKEN);

    if (!decoded || !decoded.email) {
      return res.status(401).json({ success: false, message: "Invalid token" });
    }

    const clientEmail = decoded.email;
    
    // Use the new method that returns only necessary fields
    const client = await vaClientService.getClientProfileByEmail(clientEmail);
    
    if (!client) {
      return res.status(404).json({ 
        success: false, 
        message: "Client not found" 
      });
    }

    // Format the response to only include userDetails
    const profileData = {
      name: client.userDetails?.name || '',
      email: client.userDetails?.email || '',
      address: client.userDetails?.address || '',
      city: client.userDetails?.city || '',
      state: client.userDetails?.state || '',
      zip: client.userDetails?.zip || '',
      position: client.userDetails?.position || ''
    };

    return res.status(200).json({ 
      success: true, 
      data: profileData 
    });
  } catch (error) {
    logger.error(`ClientController - Get dashboard profile error: ${error.message}`);
    return res.status(500).json({ 
      success: false, 
      message: "Internal Server Error" 
    });
  }
}

async function update_client_password(req, res) {
  logger.info("ClientController - Update Client Password Hit ...");
  console.log("Update Client Password - Request Body:", req.body);
  try {
    const accessToken = req.headers.token;        
    
    if (!accessToken) {
      return res.status(401).json({ success: false, message: "Missing token" });
    }

    const decoded = jwt.verify(accessToken, process.env.JWT_SECRET_ACCESS_TOKEN);

    if (!decoded || !decoded.email) {
      return res.status(401).json({ success: false, message: "Invalid token" });
    }

    const clientEmail = decoded.email;
    const payload = req.body || {};
    const { userDetails } = payload;
    
    // Get client by email to get the ID
    const client = await vaClientService.getClientByEmail(clientEmail);
    
    if (!client) {
      return res.status(404).json({ 
        success: false, 
        message: "Client not found" 
      });
    }

    const clientId = client._id;

    // Call service to update password
    const result = await vaClientService.updateClientPassword(clientId, userDetails);

    logger.info(`ClientController - Client password updated successfully: ${clientEmail}`);
    
    return res.status(200).json({ 
      success: true, 
      message: "Password updated successfully",
      data: result
    });

  } catch (error) {
    logger.error(`ClientController - Update password error: ${error.message}`);
    
    if (error.message === "Client not found") {
      return res.status(404).json({ 
        success: false, 
        message: error.message 
      });
    }

    if (error.message.includes("Current password is incorrect") ||
        error.message.includes("New passwords do not match") ||
        error.message.includes("All password fields are required")) {
      return res.status(400).json({ 
        success: false, 
        message: error.message 
      });
    }

    return res.status(500).json({ 
      success: false, 
      message: "Internal Server Error" 
    });
  }
}

export { 
  va_register_client, 
  get_client_profile,
  delete_client,
  update_client,
  get_client_dashboard_profile,
  update_client_password
};