import { Request, Response } from 'express';
import { ContractType } from '../models/ContractType';

// Get all contract types
export const getContractTypes = async (req: Request, res: Response) => {
  try {
    const { includeInactive } = req.query;
    const query = includeInactive === 'true' ? {} : { isActive: true };
    const types = await ContractType.find(query).sort({ name: 1 });
    res.json({ success: true, data: types });
  } catch (error: any) {
    res.status(500).json({ success: false, message: error.message });
  }
};

// Get single contract type by ID
export const getContractTypeById = async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const type = await ContractType.findById(id);
    
    if (!type) {
      return res.status(404).json({ success: false, message: 'Contract type not found' });
    }
    
    res.json({ success: true, data: type });
  } catch (error: any) {
    res.status(500).json({ success: false, message: error.message });
  }
};

// Create new contract type
export const createContractType = async (req: Request, res: Response) => {
  try {
    const { name, code, description } = req.body;

    // Validate required fields
    if (!name || !code) {
      return res.status(400).json({ success: false, message: 'Name and code are required' });
    }

    // Check if type with same name or code exists
    const existingType = await ContractType.findOne({
      $or: [{ name }, { code: code.toUpperCase() }]
    });

    if (existingType) {
      return res.status(400).json({ success: false, message: 'Contract type with this name or code already exists' });
    }

    const newType = new ContractType({
      name,
      code: code.toUpperCase(),
      description,
      isActive: true,
    });

    await newType.save();

    res.status(201).json({ success: true, message: 'Contract type created successfully', data: newType });
  } catch (error: any) {
    res.status(500).json({ success: false, message: error.message });
  }
};

// Update contract type
export const updateContractType = async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const updateData = { ...req.body };

    // Remove _id from update data
    delete updateData._id;

    // If code is being updated, ensure it's uppercase
    if (updateData.code) {
      updateData.code = updateData.code.toUpperCase();
    }

    // Check for duplicate name or code if updating
    if (updateData.name || updateData.code) {
      const existingType = await ContractType.findOne({
        _id: { $ne: id },
        $or: [
          updateData.name ? { name: updateData.name } : {},
          updateData.code ? { code: updateData.code.toUpperCase() } : {}
        ]
      });

      if (existingType) {
        return res.status(400).json({ success: false, message: 'Contract type with this name or code already exists' });
      }
    }

    const type = await ContractType.findByIdAndUpdate(
      id,
      { $set: updateData },
      { new: true, runValidators: true }
    );

    if (!type) {
      return res.status(404).json({ success: false, message: 'Contract type not found' });
    }

    res.json({ success: true, message: 'Contract type updated successfully', data: type });
  } catch (error: any) {
    res.status(500).json({ success: false, message: error.message });
  }
};

// Delete contract type (soft delete by setting isActive to false)
export const deleteContractType = async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const { hardDelete } = req.query;

    const type = await ContractType.findById(id);

    if (!type) {
      return res.status(404).json({ success: false, message: 'Contract type not found' });
    }

    // Check if type is being used in contracts
    if (hardDelete !== 'true') {
      const { Contract } = await import('../models/Contract');
      const contractsUsingType = await Contract.countDocuments({ contractType: type.code });
      
      if (contractsUsingType > 0) {
        return res.status(400).json({ 
          success: false, 
          message: `Cannot delete contract type. It is being used in ${contractsUsingType} contract(s). Use hardDelete=true to force delete.` 
        });
      }
    }

    if (hardDelete === 'true') {
      // Hard delete
      await ContractType.findByIdAndDelete(id);
      res.json({ success: true, message: 'Contract type deleted successfully' });
    } else {
      // Soft delete
      type.isActive = false;
      await type.save();
      res.json({ success: true, message: 'Contract type deactivated successfully', data: type });
    }
  } catch (error: any) {
    res.status(500).json({ success: false, message: error.message });
  }
};