// models/Product.ts
import mongoose, { Schema, Document, Types } from "mongoose";
import MainModel from "../../connect/mongoose.ts";

interface AssetEventSchema {
    modelUuid: string;
    modelName: string;
    position: [number, number, number];
    rotation: [number, number, number];
    state: "idle" | "running" | "stopped" | "disabled" | "error";
};

interface TriggerSchema {
    triggerUuid: string;
    triggerName: string;
    triggerType: "onComplete" | "onStart" | "onStop" | "delay" | "onError";
    delay: number;
    triggeredAsset: {
        triggeredModel: { modelName: string, modelUuid: string };
        triggeredPoint: { pointName: string, pointUuid: string };
        triggeredAction: { actionName: string, actionUuid: string };
    } | null;
}

interface ConveyorPointSchema {
    uuid: string;
    position: [number, number, number];
    rotation: [number, number, number];
    action: {
        actionUuid: string;
        actionName: string;
        actionType: "default" | "spawn" | "swap" | "despawn";
        material: string;
        delay: number | "inherit";
        spawnInterval: number | "inherit";
        spawnCount: number | "inherit";
        triggers: TriggerSchema[];
    };
}

interface VehiclePointSchema {
    uuid: string;
    position: [number, number, number];
    rotation: [number, number, number];
    action: {
        actionUuid: string;
        actionName: string;
        actionType: "travel";
        material: string | null;
        unLoadDuration: number;
        loadCapacity: number;
        pickUpPoint: { x: number; y: number, z: number } | null;
        unLoadPoint: { x: number; y: number, z: number } | null;
        triggers: TriggerSchema[];
    };
}

interface RoboticArmPointSchema {
    uuid: string;
    position: [number, number, number];
    rotation: [number, number, number];
    actions: {
        actionUuid: string;
        actionName: string;
        actionType: "pickAndPlace";
        process: { startPoint: [number, number, number]; endPoint: [number, number, number] };
        triggers: TriggerSchema[];
    }[];
}

interface MachinePointSchema {
    uuid: string;
    position: [number, number, number];
    rotation: [number, number, number];
    action: {
        actionUuid: string;
        actionName: string;
        actionType: "process";
        processTime: number;
        swapMaterial: string;
        triggers: TriggerSchema[];
    };
}

interface StoragePointSchema {
    uuid: string;
    position: [number, number, number];
    rotation: [number, number, number];
    action: {
        actionUuid: string;
        actionName: string;
        actionType: "storage";
        materials: { materialName: string; materialId: string; }[];
        storageCapacity: number;
    };
}

interface ConveyorEventSchema extends AssetEventSchema {
    type: "transfer";
    speed: number;
    points: ConveyorPointSchema[];
}

interface VehicleEventSchema extends AssetEventSchema {
    type: "vehicle";
    speed: number;
    point: VehiclePointSchema;
}

interface RoboticArmEventSchema extends AssetEventSchema {
    type: "roboticArm";
    speed: number;
    point: RoboticArmPointSchema;
}

interface MachineEventSchema extends AssetEventSchema {
    type: "machine";
    // speed: number;
    point: MachinePointSchema;
}

interface StorageEventSchema extends AssetEventSchema {
    type: "storageUnit";
    // speed: number;
    point: StoragePointSchema;
}
interface IPointModel extends Document {
    modelUuid:String,
    modelName:String,
    position:String,
    rotation:String,
    state:String,
    productId:String,
    isArchive:boolean,
  type: "transfer" | "vehicle" | "roboticArm" | "machine" |"storageUnit";
  speed: number;
  point: VehicleEventSchema | RoboticArmEventSchema | MachineEventSchema | StorageEventSchema
  points: ConveyorEventSchema[]

}
// type EventsSchema = ConveyorEventSchema | VehicleEventSchema | RoboticArmEventSchema | MachineEventSchema | StorageEventSchema;


const BaseEventSchema = new Schema<IPointModel>(
    {
      modelUuid: { type: String, required: true },
      modelName: { type: String, required: true },
      position: { type: [Number], required: true },
      rotation: { type: [Number], required: true },
      speed: { type: Number,},
      state: {
        type: String,
        enum: ["idle", "running", "stopped", "disabled", "error"],
        default: "idle"
      },
      type: {
        type: String,
        required: true,
        enum: ["transfer", "vehicle", "roboticArm", "machine", "storageUnit"]
      },
      point:{
        type:Schema.Types.Mixed,

      },
      points:{
        type:Schema.Types.Mixed,

      },
      productId: { type:String,required: true },
      isArchive: { type: Boolean, default: false }
    },
    { discriminatorKey: "type", timestamps: true }
  );
  
  const EventsDataModel = (db: string) => {
    return MainModel(db, "EventDatas", BaseEventSchema, "EventDatas");
  };
  
  export default EventsDataModel;