import { Injectable, HttpStatus } from '@nestjs/common';
import { Kysely } from 'kysely';
import { DB } from '@/database/database.type';
import { Logger } from 'pino-nestjs';
import { FeatureFlagsService } from '../feature-flags/feature-flags.service';
import { FEATURE_FLAG_DEFAULTS, FEATURE_FLAG_KEYS } from '../feature-flags/feature-flags.constants';

function getFeatureFlagDefaultsAsSettings(): Record<string, string> {
  const out: Record<string, string> = {};
  for (const key of FEATURE_FLAG_KEYS) {
    out[key] = FEATURE_FLAG_DEFAULTS[key] ? 'true' : 'false';
  }
  return out;
}

/** Default fallback values if DB query fails */
const DEFAULTS: Record<string, string> = {
  free_max_reports: '1',
  free_max_lost_reports: '1',
  free_max_found_reports: '1',
  free_max_profiles: '1',
  free_max_photos: '1',
  premium_max_photos: '5',
  free_ai_detections_per_day: '0',
  premium_ai_detections_per_day: '10',
  premium_monthly_price: '4.99',
  premium_yearly_price: '49.99',
  premium_yearly_savings_pct: '17',
  premium_monthly_breakdown: '4.17',
  signup_bonus_months: '1',
  boost_price: '0',
  boost_duration_days: '3',
  ios_current_version: '',
  android_current_version: '',
  ios_minimum_version: '',
  android_minimum_version: '',
  force_update: 'false',
  update_message: '',
  ios_store_url: '',
  android_store_url: '',
  google_ads_enabled: 'true',
  own_ads_enabled: 'true',
  ...getFeatureFlagDefaultsAsSettings(),
};

@Injectable()
export class BusinessConfigService {
  constructor(
    private readonly db: Kysely<DB>,
    private readonly logger: Logger,
    private readonly featureFlagsService: FeatureFlagsService,
  ) {}

  private parseBoolean(value: unknown): boolean {
    if (typeof value === 'boolean') return value;
    if (typeof value === 'string') {
      const normalized = value.trim().toLowerCase();
      return normalized === 'true' || normalized === '1' || normalized === 'yes';
    }
    return false;
  }

  private buildVersionPolicy(config: Record<string, any>) {
    return {
      ios_version: String(config.ios_current_version || ''),
      android_version: String(config.android_current_version || ''),
      ios_minimum_version: String(config.ios_minimum_version || ''),
      android_minimum_version: String(config.android_minimum_version || ''),
      force_update: this.parseBoolean(config.force_update),
      update_message: String(config.update_message || ''),
      ios_store_url: String(config.ios_store_url || ''),
      android_store_url: String(config.android_store_url || ''),
    };
  }
  async getAppConfig() {
    try {
      // 1. Fetch flat settings
      const settingsResult = await this.db
        .selectFrom('app_settings')
        .select(['key', 'value'])
        .where('deleted_at', 'is', null)
        .orderBy('key', 'asc')
        .execute();

      const config: Record<string, any> = { ...DEFAULTS };
      for (const row of settingsResult) {
        config[row.key] = row.value;
      }

      // 2. Fetch features list
      const featuresResult = await this.db
        .selectFrom('pricing_features')
        .select(['icon', 'label', 'free_value as free', 'premium_value as premium'])
        .where('deleted_at', 'is', null)
        .orderBy('display_order', 'asc')
        .execute();

      config.features = featuresResult;
      config.version_policy = this.buildVersionPolicy(config);
      config.feature_flags = await this.featureFlagsService.getFeatureFlags();

      return {
        status: true,
        statusCode: HttpStatus.OK,
        data: config,
      };
    } catch (error) {
      this.logger.error('Error fetching app settings from DB, returning defaults', error);
      // Return defaults so the app never hard-breaks
      return {
        status: true,
        statusCode: HttpStatus.OK,
        data: {
          ...DEFAULTS,
          features: [],
          version_policy: this.buildVersionPolicy(DEFAULTS),
          feature_flags: { ...FEATURE_FLAG_DEFAULTS },
        },
      };
    }
  }
}