/**
 * Feature Flags System for A/B Testing
 */

export interface FeatureFlag {
  id: string;
  name: string;
  description: string;
  enabled: boolean;
  rolloutPercentage: number;
  targetSegments: string[];
  createdAt: Date;
  updatedAt: Date;
}

export interface FeatureFlagConfig {
  id: string;
  name: string;
  description: string;
  enabled: boolean;
  rolloutPercentage: number;
  targetSegments: string[];
  variants?: {
    control: string;
    treatment: string;
  };
  metrics?: {
    conversions: number;
    impressions: number;
    conversionRate: number;
  };
}

/**
 * In-memory feature flags store
 * In production, this should be backed by a database
 */
const featureFlags: Map<string, FeatureFlag> = new Map([
  [
    'new_game_ui',
    {
      id: 'new_game_ui',
      name: 'New Game UI',
      description: 'Rollout new game interface design',
      enabled: true,
      rolloutPercentage: 25,
      targetSegments: ['beta_testers', 'vip_users'],
      createdAt: new Date(),
      updatedAt: new Date(),
    },
  ],
  [
    'bonus_rounds_v2',
    {
      id: 'bonus_rounds_v2',
      name: 'Bonus Rounds V2',
      description: 'New bonus round mechanics',
      enabled: false,
      rolloutPercentage: 10,
      targetSegments: ['beta_testers'],
      createdAt: new Date(),
      updatedAt: new Date(),
    },
  ],
  [
    'social_features',
    {
      id: 'social_features',
      name: 'Social Features',
      description: 'In-game chat and social integration',
      enabled: true,
      rolloutPercentage: 50,
      targetSegments: [],
      createdAt: new Date(),
      updatedAt: new Date(),
    },
  ],
]);

/**
 * User segment definitions
 */
const userSegments = {
  beta_testers: (userId: string) => userId.startsWith('beta_'),
  vip_users: (userId: string) => userId.startsWith('vip_'),
  new_users: (userId: string) => parseInt(userId) > 100000,
  high_value: (userId: string) => parseInt(userId) % 10 === 0,
};

/**
 * Check if feature is enabled for user
 */
export function isFeatureEnabled(featureFlagId: string, userId: string): boolean {
  const flag = featureFlags.get(featureFlagId);

  if (!flag || !flag.enabled) {
    return false;
  }

  // Check if user is in target segments
  if (flag.targetSegments.length > 0) {
    const inSegment = flag.targetSegments.some((segment) => {
      const segmentFn = userSegments[segment as keyof typeof userSegments];
      return segmentFn && segmentFn(userId);
    });

    if (!inSegment) {
      return false;
    }
  }

  // Check rollout percentage using user ID hash
  const hash = hashUserId(userId);
  const percentage = (hash % 100) + 1;

  return percentage <= flag.rolloutPercentage;
}

/**
 * Get feature flag details
 */
export function getFeatureFlag(featureFlagId: string): FeatureFlag | undefined {
  return featureFlags.get(featureFlagId);
}

/**
 * Get all feature flags
 */
export function getAllFeatureFlags(): FeatureFlag[] {
  return Array.from(featureFlags.values());
}

/**
 * Create feature flag
 */
export function createFeatureFlag(config: Omit<FeatureFlag, 'createdAt' | 'updatedAt'>): FeatureFlag {
  const flag: FeatureFlag = {
    ...config,
    createdAt: new Date(),
    updatedAt: new Date(),
  };

  featureFlags.set(config.id, flag);
  console.log(`[FeatureFlags] Created flag: ${config.id}`);

  return flag;
}

/**
 * Update feature flag
 */
export function updateFeatureFlag(featureFlagId: string, updates: Partial<FeatureFlag>): FeatureFlag | undefined {
  const flag = featureFlags.get(featureFlagId);

  if (!flag) {
    return undefined;
  }

  const updated: FeatureFlag = {
    ...flag,
    ...updates,
    updatedAt: new Date(),
  };

  featureFlags.set(featureFlagId, updated);
  console.log(`[FeatureFlags] Updated flag: ${featureFlagId}`);

  return updated;
}

/**
 * Delete feature flag
 */
export function deleteFeatureFlag(featureFlagId: string): boolean {
  const deleted = featureFlags.delete(featureFlagId);

  if (deleted) {
    console.log(`[FeatureFlags] Deleted flag: ${featureFlagId}`);
  }

  return deleted;
}

/**
 * Enable feature flag
 */
export function enableFeatureFlag(featureFlagId: string): FeatureFlag | undefined {
  return updateFeatureFlag(featureFlagId, { enabled: true });
}

/**
 * Disable feature flag
 */
export function disableFeatureFlag(featureFlagId: string): FeatureFlag | undefined {
  return updateFeatureFlag(featureFlagId, { enabled: false });
}

/**
 * Set rollout percentage
 */
export function setRolloutPercentage(featureFlagId: string, percentage: number): FeatureFlag | undefined {
  if (percentage < 0 || percentage > 100) {
    throw new Error('Rollout percentage must be between 0 and 100');
  }

  return updateFeatureFlag(featureFlagId, { rolloutPercentage: percentage });
}

/**
 * Add target segment
 */
export function addTargetSegment(featureFlagId: string, segment: string): FeatureFlag | undefined {
  const flag = featureFlags.get(featureFlagId);

  if (!flag) {
    return undefined;
  }

  if (!flag.targetSegments.includes(segment)) {
    flag.targetSegments.push(segment);
    return updateFeatureFlag(featureFlagId, { targetSegments: flag.targetSegments });
  }

  return flag;
}

/**
 * Remove target segment
 */
export function removeTargetSegment(featureFlagId: string, segment: string): FeatureFlag | undefined {
  const flag = featureFlags.get(featureFlagId);

  if (!flag) {
    return undefined;
  }

  const updated = flag.targetSegments.filter((s) => s !== segment);
  return updateFeatureFlag(featureFlagId, { targetSegments: updated });
}

/**
 * Get feature flags for user
 */
export function getUserFeatureFlags(userId: string): Record<string, boolean> {
  const flags: Record<string, boolean> = {};

  featureFlags.forEach((flag) => {
    flags[flag.id] = isFeatureEnabled(flag.id, userId);
  });

  return flags;
}

/**
 * Hash user ID for consistent rollout
 */
function hashUserId(userId: string): number {
  let hash = 0;

  for (let i = 0; i < userId.length; i++) {
    const char = userId.charCodeAt(i);
    hash = (hash << 5) - hash + char;
    hash = hash & hash; // Convert to 32-bit integer
  }

  return Math.abs(hash);
}

/**
 * Get feature flag statistics
 */
export function getFeatureFlagStats(featureFlagId: string): any {
  const flag = featureFlags.get(featureFlagId);

  if (!flag) {
    return null;
  }

  return {
    id: flag.id,
    name: flag.name,
    enabled: flag.enabled,
    rolloutPercentage: flag.rolloutPercentage,
    targetSegments: flag.targetSegments,
    usersAffected: Math.floor(Math.random() * 10000), // Simulated
    conversionRate: (Math.random() * 0.1).toFixed(2), // Simulated
    createdAt: flag.createdAt,
    updatedAt: flag.updatedAt,
  };
}