import mongoose from "mongoose";

const permitsModel = mongoose.model(
  "permit",
  new mongoose.Schema(
    {
      tenantId: {
        type: String,
        required: true,
      },
      pid: {
        type: String,
        unique: true,
      },
      permitNumber: String,
      county: Object,
      client: {
        type: mongoose.Types.ObjectId,
        ref: "organization",
      },
      clientData: Object,
      permitDate: Date,
      stage: new mongoose.Schema(
        {
          pipeline: Array,
          currentStage: Number,
        },
        { _id: false }
      ),
      status: String,
      manualStatus: String,
      utility: String,
      assignedTo: {
        type: mongoose.Types.ObjectId,
        ref: "user",
      },
      link: String,
      address: Object,
      recordType: String,
      description: String,
      applicationDetails: Object,
      applicationInfo: Object,
      applicationInfoTable: Object,
      conditions: Array,
      ownerDetails: String,
      parcelInfo: Object,
      paymentData: Object,
      professionalsList: Array,
      inspections: Object,
      createdAt: Date,
      createdBy: {
        type: mongoose.Types.ObjectId,
        ref: "user",
      },
      newProcessingStatus: Array,
      newPayment: Array,
      newConditions: Array,
      professionals: Object,
      recordId: String,
      relatedRecords: Object,
      accelaStatus: String,
      openDate: Date,
      lastUpdateDate: Date,
      statusUpdated: Date,
      issuedDate: Date,
      lot: String,
      block: String,
      jobNumber: String,
      startDate: Date,
      history: Array,
    },
    { strict: false }
  )
);

const processedModel = mongoose.model(
  "processed",
  new mongoose.Schema(
    {
      tenantId: {
        type: String,
        required: true,
      },
      pid: {
        type: String,
        unique: true,
      },
      permitNumber: String,
      county: Object,
      client: {
        type: mongoose.Types.ObjectId,
        ref: "organization",
      },
      clientData: Object,
      permitDate: Date,
      stage: new mongoose.Schema(
        {
          pipeline: Array,
          currentStage: Number,
        },
        { _id: false }
      ),
      status: String,
      manualStatus: String,
      utility: String,
      assignedTo: {
        type: mongoose.Types.ObjectId,
        ref: "user",
      },
      link: String,
      address: Object,
      recordType: String,
      description: String,
      applicationDetails: Object,
      applicationInfo: Object,
      applicationInfoTable: Object,
      conditions: Array,
      ownerDetails: String,
      parcelInfo: Object,
      paymentData: Object,
      professionalsList: Array,
      inspections: Object,
      createdAt: Date,
      createdBy: {
        type: mongoose.Types.ObjectId,
        ref: "user",
      },
      newProcessingStatus: Array,
      newPayment: Array,
      newConditions: Array,
      professionals: Object,
      recordId: String,
      relatedRecords: Object,
      accelaStatus: String,
      openDate: Date,
      lastUpdateDate: Date,
      statusUpdated: Date,
      issuedDate: Date,
      communityName: String,
      lot: String,
      block: String,
      jobNumber: String,
      transferDate: Date,
    },
    { strict: false }
  ),
  "processed"
);

(async () => {
  console.log(new Date().toISOString() + " Started Archive script...");

  await mongoose.connect(process.env.DB_URI);

  const processedPermits = await permitsModel.find({
    $or: [
      { manualStatus: { $in: ["Issued", "Invoiced", "Paid", "Closed"] } },
      {
        $and: [
          { manualStatus: { $nin: ["Issued", "Invoiced", "Paid", "Closed"] } },
          { accelaStatus: { $nin: ["OPEN", "PENDING"] } },
        ],
      },
    ],
  });

  console.log(`Found ${processedPermits.length} to archive`);

  let count = 0;
  for (const permit of processedPermits) {
    try {
      await processedModel.create({
        tenantId: permit.tenantId,
        pid: permit.pid,
        permitNumber: permit.permitNumber,
        county: permit.county,
        client: permit.client,
        clientData: permit.clientData,
        status: permit.status,
        manualStatus: permit.manualStatus,
        utility: permit.utility,
        assignedTo: permit.assignedTo,
        link: permit.link,
        address: permit.address,
        recordType: permit.recordType,
        description: permit.description,
        createdAt: permit.createdAt,
        createdBy: permit.createdBy,
        newProcessingStatus: permit.newProcessingStatus,
        newPayment: permit.newPayment,
        newConditions: permit.newConditions,
        professionals: permit.professionals,
        recordId: permit.recordId,
        relatedRecords: permit.relatedRecords,
        accelaStatus: permit.accelaStatus,
        openDate: permit.openDate,
        lastUpdateDate: permit.lastUpdateDate,
        statusUpdated: permit.statusUpdated,
        communityName: permit.communityName,
        lot: permit.lot,
        block: permit.block,
        jobNumber: permit.jobNumber,
        issuedDate: permit.issuedDate,
        transferDate: new Date(),
      });

      await permit.deleteOne();
    } catch (err) {
      console.log(err);
    }

    count++;
  }

  console.log(`${count} permits archived`);

  await mongoose.connection.close();
})().catch((err) => console.log(err));