import mongoose from "mongoose";

const SiteConfigSchema = new mongoose.Schema(
  {
    // Site maintenance settings
    maintenance: {
      enabled: { type: Boolean, default: false },
      message: {
        type: String,
        default:
          "We're currently performing maintenance. Please check back soon!",
      },
      allowedSteamIds: { type: [String], default: [] }, // Admins who can access during maintenance
      scheduledStart: { type: Date, default: null },
      scheduledEnd: { type: Date, default: null },
    },

    // Site announcements
    announcements: [
      {
        id: { type: String, required: true },
        type: {
          type: String,
          enum: ["info", "warning", "success", "error"],
          default: "info",
        },
        message: { type: String, required: true },
        enabled: { type: Boolean, default: true },
        startDate: { type: Date, default: null },
        endDate: { type: Date, default: null },
        dismissible: { type: Boolean, default: true },
        createdBy: { type: String, required: true }, // Admin username
        createdAt: { type: Date, default: Date.now },
      },
    ],

    // Promotions
    promotions: [
      {
        id: { type: String, required: true },
        name: { type: String, required: true },
        description: { type: String, required: true },
        type: {
          type: String,
          enum: ["deposit_bonus", "discount", "free_item", "custom"],
          required: true,
        },
        enabled: { type: Boolean, default: true },
        startDate: { type: Date, default: null },
        endDate: { type: Date, default: null },

        // Bonus settings
        bonusPercentage: { type: Number, default: 0 }, // e.g., 10 for 10%
        bonusAmount: { type: Number, default: 0 }, // Fixed bonus amount
        minDeposit: { type: Number, default: 0 },
        maxBonus: { type: Number, default: 0 },

        // Discount settings
        discountPercentage: { type: Number, default: 0 },

        // Usage limits
        maxUsesPerUser: { type: Number, default: 1 },
        maxTotalUses: { type: Number, default: null },
        currentUses: { type: Number, default: 0 },

        // Targeting
        newUsersOnly: { type: Boolean, default: false },

        // Metadata
        code: { type: String, default: null }, // Optional promo code
        bannerImage: { type: String, default: null },
        createdBy: { type: String, required: true },
        createdAt: { type: Date, default: Date.now },
      },
    ],

    // Trading settings
    trading: {
      enabled: { type: Boolean, default: true },
      depositEnabled: { type: Boolean, default: true },
      withdrawEnabled: { type: Boolean, default: true },
      minDeposit: { type: Number, default: 0.1 },
      minWithdraw: { type: Number, default: 0.5 },
      withdrawFee: { type: Number, default: 0.05 }, // 5% fee
      maxItemsPerTrade: { type: Number, default: 50 },
    },

    // Market settings
    market: {
      enabled: { type: Boolean, default: true },
      commission: { type: Number, default: 0.1 }, // 10% commission
      minListingPrice: { type: Number, default: 0.01 },
      maxListingPrice: { type: Number, default: 100000 },
      autoUpdatePrices: { type: Boolean, default: true },
      priceUpdateInterval: { type: Number, default: 3600000 }, // 1 hour in ms
    },

    // Features toggles
    features: {
      twoFactorAuth: { type: Boolean, default: true },
      emailVerification: { type: Boolean, default: true },
      giveaways: { type: Boolean, default: true },
      affiliateProgram: { type: Boolean, default: false },
      referralBonus: { type: Number, default: 0 },
    },

    // Rate limits
    rateLimits: {
      tradeOffers: {
        max: { type: Number, default: 10 },
        windowMs: { type: Number, default: 3600000 }, // 1 hour
      },
      withdrawals: {
        max: { type: Number, default: 5 },
        windowMs: { type: Number, default: 86400000 }, // 24 hours
      },
      api: {
        max: { type: Number, default: 100 },
        windowMs: { type: Number, default: 60000 }, // 1 minute
      },
    },

    // Social links
    social: {
      discord: { type: String, default: null },
      twitter: { type: String, default: null },
      facebook: { type: String, default: null },
      instagram: { type: String, default: null },
      youtube: { type: String, default: null },
    },

    // Support settings
    support: {
      email: { type: String, default: null },
      liveChatEnabled: { type: Boolean, default: false },
      ticketSystemEnabled: { type: Boolean, default: false },
    },

    // SEO settings
    seo: {
      title: { type: String, default: "TurboTrades - CS2 & Rust Trading" },
      description: {
        type: String,
        default: "Trade CS2 and Rust skins safely and securely.",
      },
      keywords: {
        type: [String],
        default: ["cs2", "rust", "trading", "skins", "csgo"],
      },
    },

    // Last updated info
    lastUpdatedBy: { type: String, default: null },
    lastUpdatedAt: { type: Date, default: Date.now },
  },
  { timestamps: true }
);

// Static method to get or create config
SiteConfigSchema.statics.getConfig = async function () {
  let config = await this.findOne();
  if (!config) {
    config = await this.create({});
  }
  return config;
};

// Method to check if maintenance mode is active
SiteConfigSchema.methods.isMaintenanceActive = function () {
  if (!this.maintenance.enabled) return false;

  const now = new Date();

  // Check if scheduled maintenance
  if (this.maintenance.scheduledStart && this.maintenance.scheduledEnd) {
    return (
      now >= this.maintenance.scheduledStart &&
      now <= this.maintenance.scheduledEnd
    );
  }

  return true;
};

// Method to check if user can access during maintenance
SiteConfigSchema.methods.canAccessDuringMaintenance = function (steamId) {
  return this.maintenance.allowedSteamIds.includes(steamId);
};

// Method to get active announcements
SiteConfigSchema.methods.getActiveAnnouncements = function () {
  const now = new Date();
  return this.announcements.filter((announcement) => {
    if (!announcement.enabled) return false;

    if (announcement.startDate && now < announcement.startDate) return false;
    if (announcement.endDate && now > announcement.endDate) return false;

    return true;
  });
};

// Method to get active promotions
SiteConfigSchema.methods.getActivePromotions = function () {
  const now = new Date();
  return this.promotions.filter((promo) => {
    if (!promo.enabled) return false;
    if (now < promo.startDate || now > promo.endDate) return false;
    if (promo.maxTotalUses && promo.currentUses >= promo.maxTotalUses)
      return false;

    return true;
  });
};

// Method to check if a promotion code is valid
SiteConfigSchema.methods.validatePromoCode = function (code) {
  const activePromos = this.getActivePromotions();
  return activePromos.find(
    (promo) => promo.code && promo.code.toLowerCase() === code.toLowerCase()
  );
};

export default mongoose.model("SiteConfig", SiteConfigSchema);