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

export interface IChapter {
  _id?: mongoose.Types.ObjectId;
  chapterNumber: number;
  title: string;
  description?: string;
  // Secure video playback ID / encrypted stream reference (CDN/HLS/Cloudflare Stream/AWS CloudFront)
  videoReference: string;
  durationMinutes?: number;
  // Downloadable resources & independent admin visibility flags
  isDownloadableScriptActive: boolean;
  scriptFileUrl?: string;
  isDownloadableHomeworkActive: boolean;
  homeworkFileUrl?: string;
  order: number;
}

export interface ICourse extends Document {
  level?: string;
  courseType: 'full_level' | 'sub_course' | 'individual_lesson';
  title: string;
  slug: string;
  description?: string;
  parentCourse?: mongoose.Types.ObjectId; // For sub-courses or individual lessons linked to a parent
  regularPrice: number;
  offerPrice?: number;
  currency: string;
  // New levels stay hidden until admin manually enables them after uploading videos
  isPublished: boolean;
  // Expiry duration per course/lesson (default: 4 months, overridable by admin)
  validityMonths: number;
  validityDays: number;
  // Gating rule: requires chapter completion before script/homework downloads unlock
  requireChapterCompletionForDownload: boolean;
  chapters: IChapter[];
  thumbnailUrl?: string;
  createdAt: Date;
  updatedAt: Date;
}

const ChapterSchema = new Schema<IChapter>(
  {
    chapterNumber: {
      type: Number,
      required: [true, 'Chapter number is required'],
    },
    title: {
      type: String,
      required: [true, 'Chapter title is required'],
      trim: true,
    },
    description: {
      type: String,
      trim: true,
    },
    videoReference: {
      type: String,
      required: [true, 'Video reference / streaming ID is required'],
      trim: true,
    },
    durationMinutes: {
      type: Number,
      default: 0,
    },
    isDownloadableScriptActive: {
      type: Boolean,
      default: false,
    },
    scriptFileUrl: {
      type: String,
      trim: true,
    },
    isDownloadableHomeworkActive: {
      type: Boolean,
      default: false,
    },
    homeworkFileUrl: {
      type: String,
      trim: true,
    },
    order: {
      type: Number,
      default: 0,
    },
  },
  { _id: true }
);

const CourseSchema: Schema<ICourse> = new Schema(
  {
    level: {
      type: String,
      default: 'General',
      trim: true,
      index: true,
    },
    courseType: {
      type: String,
      enum: {
        values: ['full_level', 'sub_course', 'individual_lesson'],
        message: '{VALUE} is not a valid course type',
      },
      required: [true, 'Course type is required'],
      index: true,
    },
    title: {
      type: String,
      required: [true, 'Course title is required'],
      trim: true,
      maxlength: [200, 'Title cannot exceed 200 characters'],
    },
    slug: {
      type: String,
      required: [true, 'Course slug is required'],
      unique: true,
      lowercase: true,
      trim: true,
      index: true,
    },
    description: {
      type: String,
      trim: true,
    },
    parentCourse: {
      type: Schema.Types.ObjectId,
      ref: 'Course',
      default: null,
    },
    regularPrice: {
      type: Number,
      required: [true, 'Regular price is required'],
      min: [0, 'Price cannot be negative'],
    },
    offerPrice: {
      type: Number,
      min: [0, 'Offer price cannot be negative'],
      default: null,
    },
    currency: {
      type: String,
      default: 'EUR',
      uppercase: true,
      trim: true,
    },
    isPublished: {
      type: Boolean,
      default: false,
      index: true,
    },
    validityMonths: {
      type: Number,
      default: 4,
      min: [0, 'Validity months cannot be negative'],
    },
    validityDays: {
      type: Number,
      default: 0,
      min: [0, 'Validity days cannot be negative'],
    },
    requireChapterCompletionForDownload: {
      type: Boolean,
      default: true,
    },
    chapters: [ChapterSchema],
    thumbnailUrl: {
      type: String,
      trim: true,
    },
  },
  {
    timestamps: true,
  }
);

// Indexes for fast searching and catalog queries
CourseSchema.index({ level: 1, isPublished: 1 });
CourseSchema.index({ courseType: 1, isPublished: 1 });

export const Course: Model<ICourse> =
  mongoose.models.Course || mongoose.model<ICourse>('Course', CourseSchema);

export default Course;