const installationController = require("../controllers/installationController")

module.exports = function (fastify, opts, next) {
  
    fastify.post("/api/createTeamMember", {
        schema: {
          description: "Create a new team member under an installation",
          tags: ["Installation"],
          summary: "Create Team Member",
          body: {
            type: "object",
            required: ["departmentId", "firstName", "phone", "password"],
            properties: {
              departmentId: { type: "string", description: "Installation ID to associate the team member with" },
              firstName: { type: "string", description: "Full name of the team member" },
              phone: { type: "string", description: "Phone number of the team member" },
              password: { type: "string", description: "Password for the team member" },
              alternativePhone: { type: "string",  },
              email: { type: "string", },
              status: { type: "string", },

            },
          },
        
        },
        handler: installationController.createTeamMember,
      });

      fastify.get("/api/getTeamMembers/:departmentId", {
        schema: {
          description: "Get all team members under a specific department",
          tags: ["Installation"],
          summary: "Get Team Members by Department ID",
          params: {
            type: "object",
            properties: {
              departmentId: { 
                type: "string", 
                description: "Department ID to fetch team members from" 
              }
            },
            required: ["departmentId"]
          },
        },
        handler: installationController.getTeamMembers
      });

      fastify.get("/api/getQuations/:installationId", {
        schema: {
          description: "Get all quatations under a specific installation",
          tags: ["Installation"],
          summary: "Get all quatations under a specific installation",
          params: {
            type: "object",
            properties: {
              installationId: { 
                type: "string", 
                description: "Installation ID to fetch team members from" 
              }
            },
            required: ["installationId"]
          },

        },
        handler: installationController.getQuotationsByInstallationId
      });
      fastify.get("/api/getQuations/:installationId/:teamMemberId", {
        schema: {
          description: "Get all quatations under a specific installation and team member",
          tags: ["Installation"],
          summary: "Get all quatations under a specific installation and team member",
          params: {
            type: "object",
            properties: {
              installationId: { 
                type: "string", 
                description: "Installation ID to fetch team members from" 
              },
              teamMemberId: { 
                type: "string", 
                description: "teamMember ID to fetch team members from" 
              }
            },
           // required: ["installationId"]
          },

        },
        handler: installationController.getQuotationsByInstallationAndTeamMember
      });
      fastify.post("/api/assignTeammember/:installationId", {
        schema: {
            description: "Assign a team member to an installation's quotation",
            tags: ["Installation"],
            summary: "Assign a team member based on installationId",
            params: {
                type: "object",
                properties: {
                    installationId: { 
                        type: "string", 
                        description: "Installation ID to fetch team members from" 
                    }
                },
                required: ["installationId"]
            },
            body: {
                type: "object",
                properties: {
                    teamMemberId: { 
                        type: "string", 
                        description: "The team member ID to assign" 
                    },
                    quotationId: { 
                        type: "string", 
                        description: "The team member ID to assign" 
                    }
                },
               // required: ["teamMemberId"]
            },
        },
        handler: installationController.assignTeamMemberToQuotation
    });
    

      fastify.get("/api/getAllInstallers/:departmentName", {
        schema: {
          description: "Get All Installtion list",
          tags: ["Installation"],
          summary: "Get All Installtion list",
          params: {
            type: "object",
            properties: {
              departmentName: { 
                type: "string", 
                description: "departmentName to fetch Installation list" 
              }
            },
            required: ["departmentName"]
          },
        },
        handler: installationController.getAllInstallers
      });

      fastify.put("/api/editTeamMember/:installationId/:teamMemberId", {
        schema: {
          description: "Update an existing team member's details",
          tags: ["Installation"],
          summary: "Edit Team Member",
          params: {
            type: "object",
            properties: {
              installationId: { type: "string", description: "Installation ID" },
              teamMemberId: { type: "string", description: "Team Member ID" }
            },
            required: ["installationId", "teamMemberId"]
          },
          body: {
            type: "object",
            properties: {
              name: { type: "string" },
              phone: { type: "string" },
              email: { type: "string" },
              alternativePhone: { type: "string" },
              status: { type: "string" }
            }
          },
          response: {
            200: {
              type: "object",
              properties: {
                simplydata: {
                  type: "object",
                  properties: {
                    error: { type: "boolean" },
                    message: { type: "string" }
                  }
                }
              }
            }
          }
        },
        handler: installationController.editTeamMember
      });
      
      fastify.delete("/api/deleteTeamMember/:installationId/:teamMemberId", {
        schema: {
          description: "Delete a team member from an installation",
          tags: ["Installation"],
          summary: "Delete Team Member",
          params: {
            type: "object",
            properties: {
              installationId: { type: "string", description: "Installation ID" },
              teamMemberId: { type: "string", description: "Team Member ID" }
            },
            required: ["installationId", "teamMemberId"]
          },
          response: {
            200: {
              type: "object",
              properties: {
                simplydata: {
                  type: "object",
                  properties: {
                    error: { type: "boolean" },
                    message: { type: "string" }
                  }
                }
              }
            }
          }
        },
        handler: installationController.deleteTeamMember
      });
      
      fastify.get("/api/getDepartmentByFirstName/:firstName", {
        schema: {
          description: "Get department details by first name",
          tags: ["Installation"],
          summary: "Fetch department's firstName and phone",
          params: {
            type: "object",
            properties: {
              firstName: { type: "string", description: "Department's first name" },
            },
            required: ["firstName"],
          },
        },
        handler: installationController.getDepartmentByFirstName,
      });
      
      fastify.get("/api/getGsmCheck/:hardwareId", {
        schema: {
          description: "Get GSM check details",
          tags: ["Installation"],
          summary: "Get GSM check details",
          params: {
            type: "object",
            properties: {
              hardwareId: { type: "string" },
            },
            required: ["hardwareId"],
          },
        },
        handler: installationController.getByHardwareId,
      });

      fastify.get("/api/getGsmCheckSupport/:hardwareId", {
        schema: {
          description: "Get GSM check details Support",
          tags: ["Installation"],
          summary: "Get GSM check details Support",
          params: {
            type: "object",
            properties: {
              hardwareId: { type: "string" },
            },
            required: ["hardwareId"],
          },
        },
        handler: installationController.getByHardwareIdSupport,
      });
      
      fastify.get("/api/getGsmCheckSupportTeamMember/:hardwareId", {
        schema: {
          description: "Get GSM check details Support Team Member",
          tags: ["Installation"],
          summary: "Get GSM check details Support Team Member",
          params: {
            type: "object",
            properties: {
              hardwareId: { type: "string" },
            },
            required: ["hardwareId"],
          },
        },
        handler: installationController.getByHardwareIdSupportTeamMember,
      });
      fastify.get("/api/getLoraCheck/:hardwareId/:tankhardwareId", {
        schema: {
          description: "Get LORA check details",
          tags: ["Installation"],
          summary: "Get LORA check details",
          params: {
            type: "object",
            properties: {
              hardwareId: { type: "string" },
              tankhardwareId: { type : "string"},
            },
            required: ["hardwareId","tankhardwareId"],
          },
        },
        handler: installationController.getByHardwareAndTankId,
      });
      fastify.get("/api/getLoraCheckSupport/:hardwareId/:tankhardwareId", {
        schema: {
          description: "Get LORA check details Support",
          tags: ["Installation"],
          summary: "Get LORA check details Support",
          params: {
            type: "object",
            properties: {
              hardwareId: { type: "string" },
              tankhardwareId: { type : "string"},
            },
            required: ["hardwareId","tankhardwareId"],
          },
        },
        handler: installationController.getByHardwareAndTankIdSupport,
      });
    
      fastify.get("/api/getLoraCheckSupportTeamMember/:hardwareId/:tankhardwareId", {
        schema: {
          description: "Get LORA check details Support Team Member",
          tags: ["Installation"],
          summary: "Get LORA check details Support Team Member",
          params: {
            type: "object",
            properties: {
              hardwareId: { type: "string" },
              tankhardwareId: { type : "string"},
            },
            required: ["hardwareId","tankhardwareId"],
          },
        },
        handler: installationController.getByHardwareAndTankIdSupportTeamMember,
      });
      fastify.get("/api/getAllocatedSensorsByTank/:customerId/:tankName", {
        schema: {
          description: "Get allocated sensors by installationId, customerId, and tankName",
          tags: ["Installation"],
          summary: "Fetch allocated sensors for a given tank",
          params: {
            type: "object",
            properties: {
            //  installationId: { type: "string" },
              customerId: { type: "string" },
              tankName: { type: "string" },
            },
            required: [ "customerId", "tankName"],
          },
        },
        handler: installationController.getAllocatedSensorsByTank,
      });
      
      fastify.post("/api/createMasterSlaveData/:installationId", {
        schema: {
          description: "Create a new Master-Slave data entry under an installation",
          tags: ["Installation"],
          summary: "Save Master-Slave Data",
          params: {
            type: "object",
            required: ["installationId"],
            properties: {
              installationId: { type: "string", description: "Installation ID" }
            }
          },
          body: {
            type: "object",
            required: ["hardwareId", "masterId"],
            properties: {
              type: { type: "string" },
              customerId: { type: "string" },
              hardwareId: { type: "string" },
              batchno: { type: "string" },
              masterId: { type: "string" },
              tankName: { type: "string" },
              tankLocation: { type: "string" },
              materialRecived: { type: "string" },
              electricityWork: { type: "string" },
              plumbingWork: { type: "string" },
              loraCheck: { type: "string" },
              materialRecievedPictures: {
                type: "array",
                items: {
                  type: "object",
                  properties: {
                    url: { type: "string", description: "Image URL" }, // No format validation
                    uploadedAt: { type: "string", format: "date-time", description: "Upload timestamp" }
                  }
                }
              },
              electricityWorkPictures: {
                type: "array",
                items: {
                  type: "object",
                  properties: {
                    url: { type: "string", description: "Image URL" }, // No format validation
                    uploadedAt: { type: "string", format: "date-time", description: "Upload timestamp" }
                  }
                }
              },
              plumbingWorkPictures: {
                type: "array",
                items: {
                  type: "object",
                  properties: {
                    url: { type: "string", description: "Image URL" }, // No format validation
                    uploadedAt: { type: "string", format: "date-time", description: "Upload timestamp" }
                  }
                }
              }
            }
          }
        },
        handler: installationController.createMasterSlaveData
      });
      
      fastify.get("/api/getmasterConnectedSlaveData/:connectedTo", {
        schema: {
          description: "Get masrter connected slave data",
          tags: ["Installation"],
          summary: "Get masrter connected slave data",
          params: {
            type: "object",
            properties: {
              connectedTo: { type: "string" },
           
            },
            required: [ "connectedTo"],
          },
        },
        handler: installationController.masterConnectedSlaveList,
      });

      fastify.get("/api/getmasterList/:customerId/:installationId", {
        schema: {
          description: "Get masrter connected slave data",
          tags: ["Installation"],
          summary: "Get masrter List",
          params: {
            type: "object",
            properties: {
              customerId: { type: "string" },
              installationId: { type: "string" },
            },
            required: [ "customerId","installationId"],
          },
        },
        handler: installationController.mastrerList,
      });
      
      fastify.get("/api/getmasterlistwithslaves/:customerId", {
        schema: {
          description: "Get masrter connected slave data with full info",
          tags: ["Installation"],
          summary: "Get masrter connected slave data with full info",
          params: {
            type: "object",
            properties: {
              customerId: { type: "string" },
              
            },
            required: [ "customerId"],
          },
        },
        handler: installationController.getMasterSlaveSummary,
      });

      fastify.get("/api/getAllmasterlistwithslaves/:customerId", {
        schema: {
          description: "Get All check masrter connected slave data with full info",
          tags: ["Installation"],
          summary: "Get All check masrter connected slave data with full info",
          params: {
            type: "object",
            properties: {
              customerId: { type: "string" },
              
            },
            required: [ "customerId"],
          },
        },
        handler: installationController.getIotDataByCustomer,
      });
      fastify.get("/api/getsinglemasterlistwithslaves/:customerId/:hardwareId", {
        schema: {
          description: "Get single check masrter connected slave data",
          tags: ["Installation"],
          summary: "Get single check masrter connected slave data",
          params: {
            type: "object",
            properties: {
              customerId: { type: "string" },
              hardwareId: { type: "string" },
            },
            required: [ "customerId"],
          },
        },
        handler: installationController.getIotDataByCustomerAndHardwareId,
      });

      fastify.get("/api/getraiseAticket/:customerId/:connected_to", {
        schema: {
          description: "Raise A Ticket for Support",
          tags: ["Support"],
          summary: "Raise A Ticket for Support",
          params: {
            type: "object",
            properties: {
              customerId: { type: "string" },
              connected_to: { type: "string" },
              
            },
            required: [ "customerId"],
          },
        },
        handler: installationController.raiseATicket,
      });

      fastify.get("/api/getraiseAticketBuildingDetails/:customerId/:connected_to/:installationId", {
        schema: {
          description: "Raise A Ticket for Support Building Details",
          tags: ["Support"],
          summary: "Raise A Ticket for Support Building Details",
          params: {
            type: "object",
            properties: {
              customerId: { type: "string" },
              connected_to: { type: "string" },
              installationId: { type: "string" },

            },
            required: [ "customerId"],
          },
        },
        handler: installationController.raiseATicketBuildingDetails,
      });


      fastify.get("/api/getraiseAticketslave/:customerId/:connected_to/:tankHardwareId", {
        schema: {
          description: "Raise A Ticket particular slave for Support",
          tags: ["Support"],
          summary: "Raise A Ticket particular slave for Support",
          params: {
            type: "object",
            properties: {
              customerId: { type: "string" },
              connected_to: { type: "string" },
              tankHardwareId: { type: "string" },

              
            },
            required: [ "customerId"],
          },
        },
        handler: installationController.raiseATicketSlave,
      });
      fastify.get("/api/getAllDisconnectedIsuues/:supportId/:customerId", {
        schema: {
          description: "Get All disconnected list for Support",
          tags: ["Support"],
          summary: "Get All disconnected list for Support",
          params: {
            type: "object",
            properties: {
              supportId: { type: "string" },
              customerId: { type: "string" },
            },
            required: [ "supportId"],
          },
        },
        handler: installationController.getDisconnectedIssuesBySupportId,
      });
      fastify.get("/api/getRemoveAllConnectedIsuues/:supportId/:hardwareId", {
        schema: {
          description: "Remove all connected list for Support",
          tags: ["Support"],
          summary: "Remove all connected list for Support",
          params: {
            type: "object",
            properties: {
              supportId: { type: "string" },
              hardwareId: { type: "string" },
            },
            required: [ "supportId"],
          },
        },
        handler: installationController.getRemoveConnectedMastersWithSlaves,
      });

      fastify.get("/api/fetchthebuildingdetails/:supportId", {
        schema: {
          description: "Get building details for Support",
          tags: ["Support"],
          summary: "Get  building details list for Support",
          params: {
            type: "object",
            properties: {
              supportId: { type: "string" },
            
            },
            required: [ "supportId"],
          },
        },
        handler: installationController.getDisconnectedCustomerDetails,
      });

      fastify.get("/api/disconnectedCustomersbyTeamMember/:support_teamMemberId", {
        schema: {
          description: "Get disconnected customer details by team member ID",
          tags: ["Support"],
          summary: "Disconnected Customer Details by Team Member",
          params: {
            type: "object",
            properties: {
              support_teamMemberId: { type: "string" }
            },
            required: ["support_teamMemberId"]
          }
        },
        handler: installationController.getDisconnectedCustomerDetailsByTeamMemberId
      });
      

      fastify.get("/api/moveisseshebuildingdetails/:supportId", {
        schema: {
          description: "Move the ticket Get building details move for Support",
          tags: ["Support"],
          summary: "Move the ticket Get  building details move  for Support",
          params: {
            type: "object",
            properties: {
              supportId: { type: "string" },
            
            },
            required: [ "supportId"],
          },
        },
        handler: installationController.getDisconnectedMoveCustomerDetails,
      });
      fastify.route({
        method: 'POST',
        url: '/api/supportCreateTeamMember/:supportId',
        schema: {
          tags: ['Support'],
          summary: 'Create a new team member under a support record',
          params: {
            type: 'object',
            properties: {
              supportId: { type: 'string', description: 'Support ID' },
            },
            required: ['supportId'],
          },
          body: {
            type: 'object',
            properties: {
              name: { type: 'string' },
              phone: { type: 'string' },
              password: { type: 'string' },
              email: { type: 'string' },
              alternativePhone: { type: 'string' },
              status: { type: 'string', enum: ['active', 'inactive'], default: 'active' }
            },
            required: [ 'name', 'phone']
          },
        },
        handler: installationController.createTeamMemberSupport
      });
      fastify.get("/api/supportTeamMembersList/:supportId/", {
        schema: {
          description: "Get all team members for a support user",
          tags: ["Support"],
          summary: "Get all team members for a support user",
          params: {
            type: "object",
            required: ["supportId"],
            properties: {
              supportId: { type: "string", description: "Support ID" }
            }
          }
        },
        handler: installationController.getAllTeamMembersListSupport
      });
      
      fastify.put("/api/supportUpdateTeamMember/:supportId/:teamMemberId", {
        schema: {
          description: "Update a support team member by ID",
          tags: ["Support"],
          summary: "Update a support team member by ID",
          params: {
            type: "object",
            required: ["supportId", "teamMemberId"],
            properties: {
              supportId: { type: "string" },
              teamMemberId: { type: "string" }
            }
          },
          body: {
            type: "object",
            properties: {
              name: { type: "string" },
              phone: { type: "string" },
              password: { type: "string" },
              email: { type: "string" },
              alternativePhone: { type: "string" },
              status: { type: "string" }
            }
          }
        },
        handler: installationController.updateTeamMemberSupport

     
      });
      fastify.delete("/api/supportDeleteTeamMember/:supportId/:teamMemberId", {
        schema: {
          description: "Delete a support team member by ID",
          tags: ["Support"],
          summary: "Delete a support team member by ID",
          params: {
            type: "object",
            required: ["supportId", "teamMemberId"],
            properties: {
              supportId: { type: "string" },
              teamMemberId: { type: "string" }
            }
          }
        },
        handler: installationController.deleteTeamMemberSupport

      
      });

      fastify.post("/api/moveIssueToCategory/:supportId", {
        schema: {
          description: "Move specific issue to a categorized bucket",
          tags: ["Support"],
          summary: "Move disconnected issue to category and remove from issues list",
          params: {
            type: "object",
            required: ["supportId"],
            properties: {
              supportId: { type: "string" },
            },
          },
          body: {
            type: "object",
            required: ["category", "hardwareId"],
            properties: {
              category: { type: "string" },
              hardwareId: { type: "string" },
            },
          },
        },
        handler: installationController.moveIssueToCategory
      });
      
      fastify.get('/api/support/categorizedIssues/:supportId/:category/:customerId', {
        schema: {
          description: 'Get all issues in a particular category for a support record',
          tags: ['Support'],
          summary: 'Fetch issues by category',
          params: {
            type: 'object',
            required: ['supportId', 'category'],
            properties: {
              supportId: { type: 'string' },
              customerId: { type: 'string' },
              category: {
                type: 'string',
                enum: ['Power Outage', 'Level1', 'Pending', 'Onsite Issues']  // your allowed categories
              }
            }
          },
        
        },
        handler:  installationController.particularCategory
      });
      
      
      fastify.post("/api/assignTeamMemberIssueToCategory/:supportId", {
        schema: {
          description: "Assign a team member to a categorized issue",
          tags: ["Support"],
          summary: "Assign a team member to a categorized issue",
          params: {
            type: "object",
            required: ["supportId"],
            properties: {
              supportId: { type: "string" },
            },
          },
          body: {
            type: "object",
            //required: [ "support_teamMemberId", "startDate", "endDate", "category", "masterHardwareId"],
            properties: {
              support_teamMemberId: { type: "string" },
              startDate: { type: "string", format: "date-time" },
              endDate: { type: "string", format: "date-time" },
              category: { type: "string" },
              masterHardwareId: { type: "string" },
            },
          },
        },
        handler: installationController.assignCategorizeIssue
      });
      

      fastify.post("/api/my-categorized-issues/:support_teamMemberId", {
        schema: {
          description: "Get the categorized issues on particular team member",
          tags: ["Support"],
          summary: "Get the categorized issues on particular team member",
          params: {
            type: "object",
            required: ["support_teamMemberId"],
            properties: {
              support_teamMemberId: { type: "string" },
            },
          },
        
        },
        handler: installationController.getCategorizedIssue
      });
    next();

}