import mongoose, { Schema } from "mongoose";
import { nanoid } from "nanoid"; // To generate unique 6-char IDs

const orderItemSchema = new Schema({
  productId: {
    type: Schema.Types.ObjectId,
    ref: "Product",
    required: true,
  },
  SKU: {
    type: String,
    required: true,
  },
  name: {
    type: String,
    required: true,
  },
  categoryName: {
    type: String, // Directly store category name
    required: true,
  },
  brandName: {
    type: String, // Directly store brand name
    required: true,
  },
  price: {
    type: Number,
    required: true,
  },
  GST: {
    type: Number,
    required: true,
  },
  HSN_Code: {
    type: Number,
    required: true,
  },
  description: {
    type: String,
  },
  image: [
    {
      public_id: String,
      url: String,
    },
  ],
  quantity: {
    type: Number,
    required: true,
    default: 1,
  },
});

const StatusHistorySchema = new mongoose.Schema({
  status: {
    type: String,
    enum: ["new", "dispatched", "cancelled", "processing", "delivered"], // Ensure this matches your status enum
    required: true,
  },
  timestamp: {
    type: Date,
    default: Date.now,
  },
});

const rdOrderSchema = new Schema(
  {
    paymentMode: {
      type: String,
      enum: ["cheque", "online-transfer", "credit"],
      required: true,
    },
    shipTo: {
      type: String,
      required: true,
    },
    billTo: {
      type: String,
      required: true,
    },
    orderItem: [orderItemSchema],
    subtotal: {
      type: Number,
      required: true,
    },
    gstTotal: {
      type: Number,
      required: true,
    },
    grandTotal: {
      type: Number,
      required: true,
    },
    status: {
      type: String,
      enum: ["new", "dispatched", "cancelled", "processing", "delivered"],
      default: "new",
    },
    statusUpdatedAt: {
      type: Date,
      default: Date.now,
    },
    uniqueId: {
      type: String,
      unique: true,
      default: () => nanoid(6), // Generates a 6-character unique ID
    },
    addedBy: {
      type: Schema.Types.ObjectId,
      ref: "RetailDistributor", // Reference to the RD placing the order
      required: true,
    },
    pd: {
      type: mongoose.Schema.Types.ObjectId,
      ref: "User", // Reference to the PD associated with the RD
      required: true,
    },
    status_timeline: {
      new: { type: Date },
      paid: { type: Date },
      processing: { type: Date },
      dispatched: { type: Date },
      delivered: { type: Date },
      cancelled: { type: Date },
      returned: { type: Date },
    },
    iscancelled: {
      type: Boolean,
      default: false,
    },
    order_Cancelled_Reason: {
      type: String,
    },
    courier_name: { type: String },
    courier_tracking_id: { type: String },
    isDelivered: { type: Boolean, required: true, default: false },
    DeliveredDate: { type: String, default: "" },
    statusHistory: [StatusHistorySchema], // Add this field to store the status history
  },
  { timestamps: true }
);

// Middleware to update the statusUpdatedAt field whenever status changes
rdOrderSchema.pre("save", function (next) {
  if (this.isModified("status")) {
    this.statusUpdatedAt = Date.now();
    // Add the new status and timestamp to statusHistory
    this.statusHistory.push({
      status: this.status,
      timestamp: this.statusUpdatedAt,
    });
  }
  next();
});

export const RdOrder = mongoose.model("RdOrder", rdOrderSchema);