const boom = require("boom");
const bcrypt = require('bcrypt');
const jwt = require('jsonwebtoken'); 
const customJwtAuth = require("../customAuthJwt");
const { Deparments } = require("../models/Department");
const { Install } = require("../models/store");
const { Counter } = require("../models/User")
const fastify = require("fastify")({
  logger: true,
  //disableRequestLogging: true,
  genReqId(req) {
    // you get access to the req here if you need it - must be a synchronous function
    return uuidv4();
  },
});


const generateTeamMemberId = async () => {
    var result = await Counter.findOneAndUpdate(
      { _id: 'teamMemberId_id' },
      { $inc: { seq: 1 } },
      { upsert: true, new: true }
    );
  
    return result.seq;
  };


exports.createTeamMember = async (request, reply) => {
    try {
      const { installationId, name, phone, password,email,alternativePhone ,status} = request.body;
  
      // Check if installation exists
      const installation = await Install.findOne({ installationId });
  
      if (!installation) {
        return reply.status(404).send({
          simplydata: {
            error: true,
            message: "Installation not found",
          },
        });
      }
  
      // Check if phone number already exists in the team
      const existingMember = installation.team_member.team_member.find(
        (member) => member.phone === phone
      );
  
      if (existingMember) {
        return reply.status(400).send({
          simplydata: {
            error: true,
            message: "Phone number already exists in the team",
          },
        });
      }
  
      // Hash password
      const hashedPassword = await bcrypt.hash(password, 10);

      const c_id = await generateTeamMemberId();
      const teamMemberId = `AWTM${c_id}`;
      // Create new team member
      const newTeamMember = {
        teamMemberId,
        name,
        phone,
        email,
        alternativePhone,
        installationTeamMemId: installationId,
        password: hashedPassword,
        status,
      };
  
      // Add to team members array
      installation.team_member.team_member.push(newTeamMember);
      await installation.save();
  
      return reply.send({
        simplydata: {
          error: false,
          message: "Team member created successfully",
          teamMemberId: newTeamMember.teamMemberId,
        },
      });
  
    } catch (err) {
      console.error("Error creating team member:", err);
      reply.status(500).send({
        simplydata: {
          error: true,
          message: "Internal server error",
        },
      });
    }
  };
  

  exports.getTeamMembers = async (request, reply) => {
    try {
      const { installationId } = request.params; // Get installationId from request params
  
      // Check if installation exists
      const installation = await Install.findOne({ installationId });
  
      if (!installation) {
        return reply.status(404).send({
          simplydata: {
            error: true,
            message: "Installation not found",
          },
        });
      }
  
      // Extract team members
      const teamMembers = installation.team_member.team_member;
  
      return reply.send({
        simplydata: {
          error: false,
          message: "Team members retrieved successfully",
          teamMembers, // Return the list of team members
        },
      });
  
    } catch (err) {
      console.error("Error fetching team members:", err);
      reply.status(500).send({
        simplydata: {
          error: true,
          message: "Internal server error",
        },
      });
    }
  };

  exports.assignTeamMemberToQuotation = async (request, reply) => {
    try {
        const { installationId } = request.params; // Get installationId from URL params
        const { teamMemberId } = request.body; // Get teamMemberId from request body

        if (!teamMemberId) {
            return reply.status(400).send({
                simplydata: {
                    error: true,
                    message: "teamMemberId is required",
                },
            });
        }

        // Find installation by installationId
        const installation = await Install.findOne({ installationId });

        if (!installation) {
            return reply.status(404).send({
                simplydata: {
                    error: true,
                    message: "Installation not found",
                },
            });
        }

        // Extract team members list
        const teamMembers = installation.team_member.team_member;

        // Check if provided teamMemberId exists in the installation's team
        const assignedTeamMember = teamMembers.find(member => member.teamMemberId === teamMemberId);

        if (!assignedTeamMember) {
            return reply.status(404).send({
                simplydata: {
                    error: true,
                    message: "Team member not found in this installation",
                },
            });
        }

        // Here, you would save the assigned team member to the quotation (modify as needed)
        const quotation = {
            installationId,
            assignedTeamMember
        };

        return reply.send({
            simplydata: {
                error: false,
                message: "Team member assigned to quotation successfully",
                quotation
            },
        });

    } catch (err) {
        console.error("Error assigning team member to quotation:", err);
        reply.status(500).send({
            simplydata: {
                error: true,
                message: "Internal server error",
            },
        });
    }
};


  exports.getAllInstallers = async (request, reply) => {
    try {
      const { departmentName } = request.params; // Get installationId from request params
  
      // Check if installation exists
      const installationList = await Deparments.find({ departmentName });
  
      if (!installationList) {
        return reply.status(404).send({
          simplydata: {
            error: true,
            message: "Installation not found",
          },
        });
      }
  
     
  
      return reply.send({
        simplydata: {
          error: false,
          installationList, // Return the list of team members
        },
      });
  
    } catch (err) {
      console.error("Error fetching team members:", err);
      reply.status(500).send({
        simplydata: {
          error: true,
          message: "Internal server error",
        },
      });
    }
  };
  
  exports.editTeamMember = async (request, reply) => {
    try {
      const { installationId, teamMemberId } = request.params;
      const updateData = request.body;
  
      // Find the installation
      const installation = await Install.findOne({ installationId });
  
      if (!installation) {
        return reply.status(404).send({
          simplydata: {
            error: true,
            message: "Installation not found",
          },
        });
      }
  
      // Find the team member
      let teamMember = installation.team_member.team_member.find(
        (member) => member.teamMemberId === teamMemberId
      );
  
      if (!teamMember) {
        return reply.status(404).send({
          simplydata: {
            error: true,
            message: "Team member not found",
          },
        });
      }
  
      // Update fields
      Object.assign(teamMember, updateData);
  
      // Save changes
      await installation.markModified("team_member.team_member");
      await installation.save();
  
      return reply.send({
        simplydata: {
          error: false,
          message: "Team member updated successfully",
        },
      });
  
    } catch (err) {
      console.error("Error updating team member:", err);
      reply.status(500).send({
        simplydata: {
          error: true,
          message: "Internal server error",
        },
      });
    }
  };

  exports.deleteTeamMember = async (request, reply) => {
    try {
      const { installationId, teamMemberId } = request.params;
  
      // Find the installation
      const installation = await Install.findOne({ installationId });
  
      if (!installation) {
        return reply.status(404).send({
          simplydata: {
            error: true,
            message: "Installation not found",
          },
        });
      }
  
      // Find index of the team member
      const memberIndex = installation.team_member.team_member.findIndex(
        (member) => member.teamMemberId === teamMemberId
      );
  
      if (memberIndex === -1) {
        return reply.status(404).send({
          simplydata: {
            error: true,
            message: "Team member not found",
          },
        });
      }
  
      // Remove the team member from the array
      installation.team_member.team_member.splice(memberIndex, 1);
  
      // Save changes
      await installation.markModified("team_member.team_member");
      await installation.save();
  
      return reply.send({
        simplydata: {
          error: false,
          message: "Team member deleted successfully",
        },
      });
  
    } catch (err) {
      console.error("Error deleting team member:", err);
      reply.status(500).send({
        simplydata: {
          error: true,
          message: "Internal server error",
        },
      });
    }
  };
  