const fastify = require("fastify");
const supplierController = require("../controllers/supplierController");
const validationHandler = require("../handlers/supplierHandler");
const { profilePictureSupplier } = require("../models/supplier");




module.exports = function (fastify, opts, next) {

  fastify.post("/api/suppliersforbooking/:customerId", {
    schema: {
      tags: ["Supplier-Data"],
      description: "This is for Get All Suppliers",
      summary: "This is for to Get All Suppliers",
      params: {
        type: "object",
        properties: {
          customerId: {
            type: "string",
            description: "customerId",
          },
        },
      },
       body: {
            type: "object",
           
            properties: {
              type_of_water: { type: "string" },
              capacity: { type: "string" },
              quantity: { type: "string" },
              date: { type: "string" },
              radius_from:{ type: "string" },
              radius_to:{ type: "string" },
               rating_to:{ type: "string" },
                rating_to:{ type: "string" },
              price_from: { type: "string" },
              price_to: { type: "string" },
               time: { type: "string" },
               pump: { type: "string" },

            },
          },
    
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    handler: validationHandler.getSuppliers,
  });


  fastify.post("/api/getSupplierswithoutbooking/:customerId", {
  schema: {
    tags: ["Supplier-Data"],
    description: "Get all suppliers with favorite & connection flags for a customer",
    summary: "List suppliers with isFavorite & isConnected",
    params: {
      type: "object",
      required: ["customerId"],
      properties: {
        customerId: { type: "string", description: "Customer ID" },
      },
    },
    // Body is not needed; keep empty schema or remove `body` entirely
  
    security: [{ basicAuth: [] }],
  },
  handler: validationHandler.getSupplierswithoutbooking, // or `exports.getSuppliers` if wired directly
});


fastify.post("/api/requestedbookings", {
  schema: {
    tags: ["Supplier-Data"],
    description: "API to create requested bookings and send to suppliers",
    summary: "Create requested booking",
    body: {
      type: "object",
      required: ["customerId", "type_of_water", "capacity", "quantity", "date", "time", "requested_suppliers"],
      properties: {
        customerId: { type: "string" },
        type_of_water: { type: "string" },
        capacity: { type: "string" },
        quantity: { type: "string" },
        date: { type: "string" },
        time: { type: "string" },
        requested_suppliers: {
          type: "array",
          items: {
            type: "object",
            required: ["supplierId", "quoted_amount"],
            properties: {
              supplierId: { type: "string" },
              quoted_amount: { type: "number" },
              time: { type: "string" }  // ✅ New field
            }
          }
        }
      }
    },
    security: [{ basicAuth: [] }]
  },
  handler: validationHandler.createRequestedBooking
});




  fastify.get("/api/connectedSuppliers/:customerId", {
    schema: {
      tags: ["Supplier-Data"],
      description: "This is for Get All connected Suppliers",
      summary: "This is for to Get All connected Suppliers",
      params: {
        type: "object",
        properties: {
          customerId: {
            type: "string",
            description: "customerId",
          },
        },
      },
    
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    //preHandler: fastify.auth([fastify.authenticate]),
    handler: validationHandler.getConnectedSuppliers,
  });


  fastify.get("/api/pendingSuppliers/:customerId", {
    schema: {
      tags: ["Supplier-Data"],
      description: "This is for Get All pending Suppliers",
      summary: "This is for to Get All pending Suppliers",
      params: {
        type: "object",
        properties: {
          customerId: {
            type: "string",
            description: "customerId",
          },
        },
      },
    
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    preHandler: fastify.auth([fastify.authenticate]),
    handler: validationHandler.getPendingSuppliers,
  });

  fastify.post("/api/plan/suppliers/:customerId", {
    schema: {
      tags: ["Supplier-Data"],
      summary: "Search suppliers for Plans page",
      description: "Filters by type_of_water, capacity×quantity, price, rating, radius, pump. No booked-tanker exclusion.",
      params: {
        type: "object",
        required: ["customerId"],
        properties: { customerId: { type: "string" } },
      },
      body: {
        type: "object",
        required: ["type_of_water", "capacity", "quantity", "frequency", "start_date", "end_date"],
        properties: {
          // UI fields
          type_of_water: { type: "string" },
          capacity: { type: "string" },
          quantity: { type: "string" },
          frequency: {
            type: "string",
          
          },
          start_date: { type: "string" },
          end_date:   { type: "string" },

          // Extra filters from your payload
          radius_from: { type: "string" },
          radius_to:   { type: "string" },
          rating_from: { type: "string" },
          rating_to:   { type: "string" },
          price_from:  { type: "string" },
          price_to:    { type: "string" },
          pump:        { type: "string" }, // "true"/"false" | "1"/"0" | "yes"/"no"
        },
        additionalProperties: false
      },
      security: [{ basicAuth: [] }],
    },
    handler: validationHandler.getSuppliersForPlanSearch,
  });

   fastify.post("/api/requestedplanbookings", {
    schema: {
      tags: ["Supplier-Data"],
      summary: "Create plan requested booking (daily/weekly once|twice|thrice)",
      body: {
        type: "object",
        required: [
          "customerId","type_of_water","capacity","quantity",
          "start_date","end_date","time","frequency","requested_suppliers"
        ],
        properties: {
          customerId: { type: "string" },
          type_of_water: { type: "string" },
          capacity: { type: "string" },
          quantity: { type: "string" },
          start_date: { type: "string" },  // "YYYY-MM-DD"
          end_date:   { type: "string" },  // "YYYY-MM-DD"
          time: { type: "string" },        // "HH:mm"
          frequency: {
            type: "string",
            enum: ["daily","weekly_once","weekly_twice","weekly_thrice","weekly"]
          },
          weekly_count: { type: "integer", minimum: 1, maximum: 3 }, // only if frequency === "weekly"
          requested_suppliers: {
            type: "array",
            minItems: 1,
            items: {
              type: "object",
              required: ["supplierId","quoted_amount"],
              properties: {
                supplierId: { type: "string" },
                quoted_amount: { type: "number" },
                time: { type: "string" }
              },
              additionalProperties: false
            }
          }
        },
        additionalProperties: false
      },
      security: [{ basicAuth: [] }]
    },
    handler: validationHandler.createRequestedPlanBooking
  });

  fastify.get("/api/rejectSuppliers/:customerId", {
    schema: {
      tags: ["Supplier-Data"],
      description: "This is for Get All rejected Suppliers",
      summary: "This is for to Get All rejected Suppliers",
      params: {
        type: "object",
        properties: {
          customerId: {
            type: "string",
            description: "customerId",
          },
        },
      },
    
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    preHandler: fastify.auth([fastify.authenticate]),
    handler: validationHandler.getRejectSuppliers,
  });



  fastify.get("/api/rejectCustomers/:supplierId", {
    schema: {
      tags: ["Supplier-Data"],
      description: "This is for Get All rejected Customers",
      summary: "This is for to Get All rejected Customers",
      params: {
        type: "object",
        properties: {
          supplierId: {
            type: "string",
            description: "supplierId",
          },
        },
      },
    
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    preHandler: fastify.auth([fastify.authenticate]),
    handler: validationHandler.getRejectCustomers,
  });


  fastify.get("/api/pendingCustomers/:supplierId", {
    schema: {
      tags: ["Supplier-Data"],
      description: "This is for Get All pending Customers",
      summary: "This is for to Get All pending Customers",
      params: {
        type: "object",
        properties: {
          supplierId: {
            type: "string",
            description: "supplierId",
          },
        },
      },
    
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    preHandler: fastify.auth([fastify.authenticate]),
    handler: validationHandler.getPendingCustomers,
  });



  fastify.get("/api/connectedCustomers/:supplierId", {
    schema: {
      tags: ["Supplier-Data"],
      description: "This is for Get All connected Customers for Suppliers",
      summary: "This is for to Get All connected Customers for suppliers",
      params: {
        type: "object",
        properties: {
          supplierId: {
            type: "string",
            description: "supplierId",
          },
        },
      },
    
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    preHandler: fastify.auth([fastify.authenticate]),
    handler: validationHandler.getconnectedCustomers,
  });
  

    fastify.post("/api/supplierlogin", {
        schema: {
          description: "This is for Login Supplier",
          tags: ["Supplier-Data"],
          summary: "This is for Login Supplier",
          body: {
            type: "object",
            required: ["phone", "password"],
            properties: {
              phone: { type: "string" },
              password: { type: "string" },
            },
          },
        },
        handler: validationHandler.loginSupplier,
  });


  fastify.post("/api/deliveryboylogin", {
    schema: {
      description: "This is for Login Delivery Boy",
      tags: ["Delivery"],
      summary: "This is for Login Delivery Boy",
      body: {
        type: "object",
        required: ["phone"],
        properties: {
          phoneVerificationCode: { type: "string" },
          phone: { type: "string" },
        },
      },
    },
    handler: validationHandler.deliveryBoyVerifyPhone,
});

  fastify.route({
    method: "POST",
    url: "/api/supplierlogout",
    schema: {
          description: "This is for Supplier logout",
          tags: ["Supplier-Data"],
          summary: "This is for Supplier logout",
          params: {
            type: "object",
            properties: {
              supplierId: {
                type: "string",
                description: "supplierId",
              },
            },
          },
        },
    // preHandler: fastify.auth([fastify.authenticate]),
    handler: validationHandler.logoutsupplier,
    // onResponse: (request,reply) => {validationHandler.resetPassword(request,reply)}
  });




  fastify.route({
    method: "POST",
    url: "/api/suppliers",
    schema: {
      tags: ["Supplier-Data"],
      description: "This is for cretae New supplier",
      summary: "This is for Create New supplier.",
      body: {
        type: "object",
        properties: {
          suppliername: { type: "string" },
          phone: { type: "string" },
          alternativeContactNumber : { type : "string" },
          password: { type: "string" },
          emails: {
            type: "array",
            maxItems: 2,
            items: {
              type: "object",
              properties: {
                email: { type: "string", default: null },
              },
            },
          },
          office_address: { type: "string", default: null },
          city: { type: "string", default: null },
          state: { type: "string", default: null },
          zip: { type: "string", default: null },
          country: { type: "string", default: null },
          latitude: { type: 'number', default: 0.0},
          longitude: { type: 'number', default: 0.0},
          fcmId: { type: "string", default: null },
          description: { type: "string", default: null },
          bussinessname: { type: "string", default: null },

          registration_number: { type: "string", default: null },
          years_in_business: { type: "string", default: null },


        },
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    preHandler: [
      validationHandler.fieldCheck,
      validationHandler.verifySupplier,
      //  validationHandler.validatePhoneFormat,
      validationHandler.validateEmailFormat,
    ],
    handler: supplierController.addSupplier,
  });


  fastify.route({
    method: "POST",
    url: "/api/supplierphone",
    schema: {
      tags: ["Supplier-Data"],
      description: "This is for verify Supplier Phone",
      summary: "This is to Verify Supplier Phone.",
      body: {
        type: "object",
        required: ["phone"],
        properties: {
          phoneVerificationCode: { type: "string" },
          phone: { type: "string" },
        },
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    // preHandler: fastify.auth([fastify.authenticate]),
    handler: validationHandler.verifyPhone,
  });


  fastify.route({
    method: "POST",
    url: "/api/deliveryboyphone",
    schema: {
      tags: ["Delivery"],
      description: "This is for verify Delivery Boy Phone",
      summary: "This is to Verify Delivery Boy Phone.",
      body: {
        type: "object",
        required: ["phone"],
        properties: {
          phoneVerificationCode: { type: "string" },
          phone: { type: "string" },
        },
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    // preHandler: fastify.auth([fastify.authenticate]),
    handler: validationHandler.deliveryBoyVerifyPhone,
  });

  fastify.route({
    method: "PUT",
    url: "/api/deletedeliveryboy/:supplierId",
    schema: {
      tags: ["Delivery"],
      summary: "This is for delete delivery boy",
      description: "This is for delete delivery boy",
      params: {
        required: ["supplierId"],
        type: "object",
        properties: {
          supplierId: {
            type: "string",
            description: "supplierId",
          },
        },
      },
      querystring: {
        phone: {type: 'string'}
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    preHandler: fastify.auth([fastify.authenticate]),
    handler: validationHandler.deleteDeliveryBoy,
  });

  

  fastify.route({
    method: "PUT",
    url: "/api/updatedeliveryboy/:supplierId",
    schema: {
      tags: ["Delivery"],
      summary: "This is for update deliveryboy details",
      params: {
        required: ["supplierId"],
        type: "object",
        properties: {
          supplierId: {
            type: "string",
            description: "supplierId",
          },
        },
      },
      querystring: {
        phone: {type: 'string'}
      },
      
      body: {
        type: "object",
        // required: ['phone'],
        properties: {

            name: { type: "string", default: null },
            phone: { type: "string", default: null },
            alternativeContactNumber: { type: "string" },
            address: { type: "string", default: null },
            city: { type: "string" , default: null},
            state: { type: "string", default: null },
            zip: { type: "string", default: null },
        },
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    // preHandler: [
    //   fastify.auth([fastify.operatorAuthenticate]),
    //   validationHandler.validatePhoneFormat,
    // ],
    preHandler: fastify.auth([fastify.authenticate]),
    handler: validationHandler.updateDeliveryBoy,
  });



  fastify.route({
    method: "POST",
    url: "/api/suppliers/:supplierId",
    schema: {
      description: "To Get Supplier by supplierId",
      tags: ["Supplier-Data"],
      summary: "This is for Get a Single Supplier by supplierId",
      params: {
        type: "object",
        properties: {
          supplierId: {
            type: "string",
            description: "supplierId",
          },
        },
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    preHandler: fastify.auth([fastify.authenticate]),
    handler: validationHandler.getSingleSupplier,
  });


  fastify.route({
    method: "POST",
    url: "/api/currentsupplier",
    schema: {
      tags: ["Supplier-Data"],
      description: "This is for Get Current Supplier by supplierId by Post Body",
      summary: "This is for Get a Current Supplier.",
      body: {
        type: "object",
        required: ["supplierId"],
        properties: {
          supplierId: { type: "string" },
        },
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    preHandler: fastify.auth([fastify.authenticate]),
    handler: validationHandler.getCurrentSupplier,
    
  });

  fastify.route({
    method: "PUT",
    url: "/api/update/currentSupplier/:supplierId",
    schema: {
      tags: ["Supplier-Data"],
      summary: "This is for update current supplier",
      description: "This is for update current supplier",
      params: {
        type: "object",
        properties: {
          supplierId: {
            type: "string",
            description: "supplierId",
          },
        },
      },
      body: {
        type: "object",
        properties: {
          phone: { type: "string" },
          firstName: { type: "string" },
          lastName: { type: "string" },
          suppliername: { type: "string" },
          emails: {
            type: "array",
            maxItems: 2,
            items: {
              type: "object",
              properties: {
                email: { type: "string", default: null },
              },
            },
          },
          office_address: { type: "string" },
          alternativeContactNumber: { type: "string" },
          city: { type: "string" },
          state: { type: "string" },
          country: { type: "string" },
          zip: { type: "string" },
          description: { type: "string" },
          status: {type: "string" },
          startingPrice : {type : "string"}
        },
      },
      security: [
        { 
          basicAuth: [],
        },
      ],
    },
    preHandler: [fastify.auth([fastify.authenticate])],
    handler: supplierController.editCuurentSupplierInfo,
  });



fastify.route({
  method: "POST",
  url: "/api/supplier/booking/respond/:_id",
  schema: {
    description: "Supplier accepts or rejects a requested booking",
    tags: ["Supplier-Data"],
    summary: "Supplier action on requested booking",
    params: {
      type: "object",
      properties: {
        _id: { type: "string", description: "Requested Booking ID" }
      },
      required: ["_id"]
    },
    body: {
      type: "object",
      properties: {
        supplierId: { type: "string", description: "Supplier ID" },
        action: {
          type: "string",
          enum: ["accept", "reject"],
          description: "Action to perform by supplier"
        }
      },
      required: ["supplierId", "action"]
    },
    security: [
      {
        basicAuth: [],
      },
    ],
  },
  // preHandler: fastify.auth([fastify.authenticate]), // Uncomment if auth is needed
  handler: supplierController.respondToRequestedBooking
});



  next();
}