/**
 * Pricing Addon Model
 * Defines add-on products (WhatsApp API, CRM, Zapier, etc.)
 * that can be purchased alongside or independent of subscription packages.
 */

import mongoose, { Schema, Document } from 'mongoose';

export type PricingAddonMode = 'per_unit' | 'flat';

export interface IPricingAddon extends Document {
  slug: string;
  name: string;
  description?: string;
  icon?: string;
  categorySlug: string;
  pricingMode: PricingAddonMode;
  monthlyPrice: number;
  quarterlyPrice: number;
  halfYearlyPrice: number;
  yearlyPrice: number;
  lifetimePrice: number;
  usageLimitKey?: string;
  defaultLimit: number;
  metadata?: Record<string, any>;
  isAvailableStandalone: boolean;
  isActive: boolean;
  sortOrder: number;
  createdAt: Date;
  updatedAt: Date;
}

const PricingAddonSchema = new Schema<IPricingAddon>({
  slug: {
    type: String,
    required: [true, 'Addon slug is required'],
    unique: true,
    trim: true,
    lowercase: true,
    match: [/^[a-z0-9_]+$/, 'Slug must contain only lowercase letters, numbers, and underscores'],
  },
  name: {
    type: String,
    required: [true, 'Addon name is required'],
    trim: true,
    maxlength: [150, 'Addon name cannot exceed 150 characters'],
  },
  description: {
    type: String,
    trim: true,
    maxlength: [1000, 'Description cannot exceed 1000 characters'],
  },
  icon: {
    type: String,
    trim: true,
    maxlength: [50, 'Icon name cannot exceed 50 characters'],
  },
  categorySlug: {
    type: String,
    required: [true, 'Category slug is required'],
    trim: true,
    lowercase: true,
  },
  pricingMode: {
    type: String,
    enum: ['per_unit', 'flat'],
    default: 'flat',
  },
  monthlyPrice: {
    type: Number,
    default: 0,
    min: [0, 'Monthly price cannot be negative'],
  },
  quarterlyPrice: {
    type: Number,
    default: 0,
    min: [0, 'Quarterly price cannot be negative'],
  },
  halfYearlyPrice: {
    type: Number,
    default: 0,
    min: [0, 'Half-yearly price cannot be negative'],
  },
  yearlyPrice: {
    type: Number,
    default: 0,
    min: [0, 'Yearly price cannot be negative'],
  },
  lifetimePrice: {
    type: Number,
    default: 0,
    min: [0, 'Lifetime price cannot be negative'],
  },
  usageLimitKey: {
    type: String,
    trim: true,
    default: null,
  },
  defaultLimit: {
    type: Number,
    default: 0,
    min: [0, 'Default limit cannot be negative'],
  },
  metadata: {
    type: Schema.Types.Mixed,
    default: {},
  },
  isAvailableStandalone: {
    type: Boolean,
    default: false,
  },
  isActive: {
    type: Boolean,
    default: true,
  },
  sortOrder: {
    type: Number,
    default: 0,
  },
}, {
  timestamps: true,
  toJSON: { virtuals: true },
  toObject: { virtuals: true },
});

PricingAddonSchema.index({ slug: 1 }, { unique: true });
PricingAddonSchema.index({ categorySlug: 1, sortOrder: 1 });
PricingAddonSchema.index({ isActive: 1 });

export const PricingAddon = mongoose.models.PricingAddon || mongoose.model<IPricingAddon>('PricingAddon', PricingAddonSchema);