import mongoose from 'mongoose';
import { generateId } from '../../utils.js';

const { Schema } = mongoose;
const RENDER_EMAIL_TEMPLATE_CALL = /fc\.renderEmailTemplate\s*\(\s*(['"])([^'"]+)\1/g;

function extractReferences(content) {
  const references = [];
  const seen = new Set();
  for (const match of String(content || '').matchAll(RENDER_EMAIL_TEMPLATE_CALL)) {
    const reference = match[2]?.trim();
    if (reference && !seen.has(reference)) {
      seen.add(reference);
      references.push(reference);
    }
  }
  return references;
}

const emailTemplateAttachmentSchema = new Schema(
  {
    type: { type: String, enum: ['file', 'documentTemplate'], required: true },
    file: { type: Schema.Types.ObjectId, refPath: 'attachments.type', required: true },
    fileName: { type: String, required: true },
    fileType: { type: String, enum: ['pdf', 'jpeg', 'png', 'svg'], required: false },
  },
  { _id: true }
);

const emailTemplateSchema = new Schema(
  {
    _reference: { type: String, default: () => generateId()() },
    name: { type: String, required: true, unique: true },
    objectType: { type: String, required: false },
    tags: [{ type: String }],
    active: { type: Boolean, required: true, default: true },
    global: { type: Boolean, required: true, default: false },
    parent: { type: Schema.Types.ObjectId, ref: 'emailTemplate', required: false },
    referencedTemplates: [
      { type: Schema.Types.ObjectId, ref: 'emailTemplate', required: false },
    ],
    subject: { type: String, required: false, default: '' },
    content: { type: String, required: false, default: '<Container></Container>' },
    testObject: { type: Schema.Types.ObjectId, refPath: 'objectType', required: false },
    attachments: { type: [emailTemplateAttachmentSchema], default: [] },
  },
  { timestamps: true }
);

emailTemplateSchema.index({ name: 'text', tags: 'text', objectType: 'text' });
emailTemplateSchema.virtual('id').get(function () {
  return this._id;
});
emailTemplateSchema.set('toJSON', { virtuals: true });

emailTemplateSchema.statics.recalculate = async function (emailTemplate, user) {
  const id = emailTemplate?._id || emailTemplate;
  if (!id || !(await this.exists({ _id: id }))) return;

  const referencedTemplates = [];
  for (const reference of extractReferences(emailTemplate?.content)) {
    const normalizedReference = reference.replace(/^ETP:/i, '').trim();
    const found = await this.findOne({ _reference: normalizedReference }).select('_id').lean();
    if (found?._id) referencedTemplates.push(found._id);
  }

  const { editObject } = await import('../../database.js');
  await editObject({
    model: this,
    id,
    updateData: { referencedTemplates },
    user,
    populate: [{ path: 'referencedTemplates', strictPopulate: false }],
    recalculate: false,
  });
};

export const emailTemplateModel = mongoose.model('emailTemplate', emailTemplateSchema);