defmodule DaProductApp.FeatureFlagsTest do
  @moduledoc """
  Simple test script to verify the feature flag system and database setup.
  Run with: elixir -r deps/*/lib/mix/tasks.ex priv/scripts/test_feature_flags.exs
  """
  
  alias DaProductApp.FeatureFlags
  alias DaProductApp.Settings
  alias DaProductApp.Settings.PlatformSetting
  alias DaProductApp.Repo
  
  require Logger
  
  def run do
    Logger.info("🚀 Testing Feature Flags and Platform Management...")
    
    # Test 1: Feature flag system
    test_feature_flags()
    
    # Test 2: Database connectivity  
    test_database_setup()
    
    # Test 3: Platform settings
    test_platform_settings()
    
    # Test 4: Settings system (gradual migration)
    test_settings_system()
    
    Logger.info("✅ All tests completed successfully!")
  end
  
  defp test_feature_flags do
    Logger.info("📋 Testing Feature Flag System...")
    
    # Test basic feature flags
    flags_to_test = [
      :use_database_settings,
      :audit_logging_enabled,
      :file_logging_fallback,
      :use_database_monitoring,
      :settlement_auto_generation,
      :api_request_logging
    ]
    
    Enum.each(flags_to_test, fn flag ->
      status = FeatureFlags.enabled?(flag)
      Logger.info("   Flag #{flag}: #{status}")
    end)
    
    # Test environment override
    original_value = FeatureFlags.enabled?(:use_database_settings)
    System.put_env("UPI_PSP_ENABLE_USE_DATABASE_SETTINGS", "true")
    new_value = FeatureFlags.enabled?(:use_database_settings)
    
    Logger.info("   Environment override test: #{original_value} -> #{new_value}")
    
    if new_value do
      Logger.info("   ✅ Environment override working")
    else
      Logger.warning("   ⚠️  Environment override may not be working")
    end
  end
  
  defp test_database_setup do
    Logger.info("📋 Testing Database Setup...")
    
    # Test table existence
    tables = ["platform_settings", "settlements", "api_request_logs", "transactions"]
    
    Enum.each(tables, fn table ->
      try do
        query = "SELECT 1 FROM #{table} LIMIT 1"
        result = Ecto.Adapters.SQL.query!(Repo, query, [])
        Logger.info("   Table #{table}: ✅ exists")
      rescue
        error ->
          Logger.error("   Table #{table}: ❌ error - #{inspect(error)}")
      end
    end)
  end
  
  defp test_platform_settings do
    Logger.info("📋 Testing Platform Settings...")
    
    # Create a test setting
    test_setting = %{
      category: "test",
      key: "feature_test",
      value: "enabled",
      value_type: "string",
      description: "Test setting for feature flag verification",
      is_active: true
    }
    
    try do
      # Insert test setting
      changeset = PlatformSetting.changeset(%PlatformSetting{}, test_setting)
      {:ok, setting} = Repo.insert(changeset)
      Logger.info("   ✅ Created test setting: #{setting.id}")
      
      # Test value parsing
      parsed_value = PlatformSetting.parse_value(setting)
      Logger.info("   ✅ Parsed value: #{inspect(parsed_value)}")
      
      # Clean up
      Repo.delete(setting)
      Logger.info("   ✅ Cleaned up test setting")
      
    rescue
      error ->
        Logger.error("   ❌ Platform settings error: #{inspect(error)}")
    end
  end
  
  defp test_settings_system do
    Logger.info("📋 Testing Settings System (Gradual Migration)...")

    # Test hardcoded settings (should always work)
    general_settings = Settings.get_settings_by_category("general")
    Logger.info("   ✅ Hardcoded settings loaded: #{map_size(general_settings)} keys")

    # Test specific setting retrieval
    app_name = Settings.get_setting("general", "app_name", "Unknown")
    Logger.info("   ✅ App name: #{app_name}")

    # Test all settings retrieval
    all_settings = Settings.get_all_settings()
    categories = Map.keys(all_settings)
    Logger.info("   ✅ Available categories: #{inspect(categories)}")

    # Test if database mode is enabled
    if FeatureFlags.enabled?(:use_database_settings) do
      Logger.info("   📊 Database settings mode: ENABLED")

      # Test database settings fallback
      test_db_setting = Settings.get_setting("general", "nonexistent_key", "default_value")
      Logger.info("   ✅ Database fallback test: #{test_db_setting}")
    else
      Logger.info("   📊 Database settings mode: DISABLED (using hardcoded)")
    end
  end
end

# Run the tests
DaProductApp.FeatureFlagsTest.run()