import { Model } from "mongoose";

import { DroneProvider } from "../constants";
import {
  currentDate,
  MongooseModule,
} from "../helpers";
import { EncryptedDataType } from "../types/common";
import {
  DroneConnectionOptionsType,
  DroneConnectionType,
} from "../types/drone-connection";

export interface DroneConnection extends DroneConnectionType, Record<string, unknown> {
}

const EncryptedDataDefault: EncryptedDataType = {
  iv: "",
  encryptedData: "",
};

export function DroneConnectionSchema(mongoose: MongooseModule) {
  const { Schema } = mongoose;

  const EncryptedData = new Schema<EncryptedDataType>({
    iv: {
      type: String,
      default: "",
    },
    encryptedData: {
      type: String,
      default: "",
    },
  }, {
    _id: false,
    id: false,
  });

  const DroneConnectionOptions = new Schema<DroneConnectionOptionsType>({
    drones: {
      type: String,
      enum: ["all", "listed"],
      default: "all",
    },
    serials: {
      type: [String],
      default: [],
    },
  }, {
    _id: false,
    id: false,
  });

  const modelSchema = new Schema<DroneConnectionType>({
    departmentId: {
      type: Schema.Types.ObjectId,
      ref: "Department",
      required: true,
    },
    provider: {
      type: String,
      enum: Object.values(DroneProvider),
      required: true,
    },
    active: {
      type: Boolean,
      default: false,
    },
    label: {
      type: String,
      default: "",
    },
    authToken: {
      type: EncryptedData,
      default: EncryptedDataDefault,
    },
    authSecret: {
      type: EncryptedData,
      default: EncryptedDataDefault,
    },
    options: {
      type: DroneConnectionOptions,
      required: false,
    },
    modified: {
      type: Date,
      default: currentDate,
    },
  }, {
    autoIndex: false,
    timestamps: {
      createdAt: false,
      updatedAt: "modified",
    },
  });

  modelSchema.index({
    departmentId: 1,
  }, {
    name: "departmentId_1",
  });

  modelSchema.index({
    departmentId: 1,
    provider: 1,
    label: 1,
  }, {
    name: "departmentId_1_provider_1_label_1_unique",
    unique: true,
  });

  return modelSchema;
}

export default async function DroneConnectionModule(mongoose: MongooseModule) {
  const modelSchema = DroneConnectionSchema(mongoose);
  return mongoose.model<DroneConnection>("DroneConnection", modelSchema, "massive_drone_connection", { overwriteModels: true });
}

export interface DroneConnectionModel extends Model<DroneConnection> {
}