package engine_router

import (
	"fmt"
	"log"

	"github.com/dustin/go-humanize"
	"github.com/pingcap-inc/clinic/clinic_data_service/pkg/config"
	"github.com/pingcap-inc/clinic/clinic_data_service/pkg/engine"
)

// Router 查询路由器，负责选择合适的查询引擎
type Router struct {
	engines map[string]engine.QueryEngine
	config  *config.DataProxyConfig
}

// NewRouter 创建路由器实例
func NewRouter(cfg *config.DataProxyConfig) (*Router, error) {
	r := &Router{
		engines: make(map[string]engine.QueryEngine),
		config:  cfg,
	}

	// 初始化 AWS Athena 引擎
	if cfg.AWS.Enabled {
		athenaEngine, err := engine.NewAthenaEngine(&engine.AthenaConfig{
			Region:         cfg.AWS.Region,
			Database:       cfg.AWS.AthenaDatabase,
			Workgroup:      cfg.AWS.AthenaWorkgroup,
			OutputLocation: cfg.AWS.AthenaOutputLocation,
			RoleArn:        cfg.AWS.RoleArn,
			AccessKey:      cfg.AWS.AccessKey,
			SecretKey:      cfg.AWS.SecretKey,
			SessionToken:   cfg.AWS.SessionToken,
		})
		if err != nil {
			return nil, fmt.Errorf("failed to create Athena engine: %w", err)
		}
		r.engines["aws"] = athenaEngine
	}

	// 初始化 GCP BigQuery 引擎
	if cfg.GCP.Enabled {
		bytes, err := humanize.ParseBytes(cfg.GCP.QueryScanBytesLimit)
		if err != nil || bytes == 0 {
			bytes, _ = humanize.ParseBytes("1GB")
		}
		bqEngine, err := engine.NewBigQueryEngine(&engine.BigQueryConfig{
			ProjectID:      cfg.GCP.ProjectID,
			Dataset:        cfg.GCP.BigQueryDataset,
			MaxBytesBilled: int64(bytes),
		})
		if err != nil {
			return nil, fmt.Errorf("failed to create BigQuery engine: %w", err)
		}
		r.engines["gcp"] = bqEngine
	}

	// 初始化阿里云 MaxCompute 引擎
	if cfg.AliCloud.Enabled {
		// MaxCompute endpoint 固定格式 https://service.{region}.maxcompute.aliyun.com/api，project = prefix_region。
		// 支持 AK/SK 或 OIDC（EKS Pod token AssumeRoleWithOIDC）认证。
		maxComputeEngine, err := engine.NewMaxComputeEngine(&engine.MaxComputeEngineConfig{
			AccessKey:                                cfg.AliCloud.MaxCompute.AccessKey,
			SecretKey:                                cfg.AliCloud.MaxCompute.SecretKey,
			ProjectPrefix:                            cfg.AliCloud.MaxCompute.ProjectPrefix,
			EnableSlowQueryParquetPredicatePushdown:  cfg.AliCloud.MaxCompute.EnableSlowQueryParquetPredicatePushdown,
			SlowQueryParquetPredicatePushdownRegions: cfg.AliCloud.MaxCompute.SlowQueryParquetPredicatePushdownRegions,
			OIDCProviderArn:                          cfg.AliCloud.MaxCompute.OIDCProviderArn,
			RoleArn:                                  cfg.AliCloud.MaxCompute.RoleArn,
			OIDCTokenFile:                            cfg.AliCloud.MaxCompute.OIDCTokenFile,
			OIDCRoleSessionSeconds:                   cfg.AliCloud.MaxCompute.OIDCRoleSessionSeconds,
			AutoCreateProject:                        cfg.AliCloud.MaxCompute.AutoCreateProject,
			ProjectProductType:                       cfg.AliCloud.MaxCompute.ProjectProductType,
			SqlMeteringMax:                           cfg.AliCloud.MaxCompute.SqlMeteringMax,
			AutoMvQuotaGb:                            cfg.AliCloud.MaxCompute.AutoMvQuotaGb,
		})
		if err != nil {
			log.Printf("Warning: Failed to create MaxCompute engine: %v", err)
			return nil, fmt.Errorf("failed to create MaxCompute engine: %w", err)
		}
		r.engines["alicloud"] = maxComputeEngine
		log.Printf(
			"MaxCompute engine initialized for alicloud (endpoint format: https://service.{region}.maxcompute.aliyun.com/api, slow_query_parquet_predicate_pushdown=%t, regions=%v)",
			cfg.AliCloud.MaxCompute.EnableSlowQueryParquetPredicatePushdown,
			cfg.AliCloud.MaxCompute.SlowQueryParquetPredicatePushdownRegions,
		)
	}

	// 初始化 Azure Synapse 引擎
	if cfg.Azure.Enabled {
		synapseEngine, err := engine.NewSynapseEngine(&engine.SynapseConfig{
			Server:              cfg.Azure.Synapse.Server,
			Port:                cfg.Azure.Synapse.Port,
			Database:            cfg.Azure.Synapse.Database,
			AuthType:            cfg.Azure.Synapse.AuthType,
			Username:            cfg.Azure.Synapse.Username,
			Password:            cfg.Azure.Synapse.Password,
			TenantID:            cfg.Azure.Synapse.TenantID,
			ClientID:            cfg.Azure.Synapse.ClientID,
			ClientSecret:        cfg.Azure.Synapse.ClientSecret,
			QueryTimeoutSeconds: cfg.Azure.Synapse.QueryTimeoutSeconds,
			MaxOpenConns:        cfg.Azure.Synapse.MaxOpenConns,
			MaxIdleConns:        cfg.Azure.Synapse.MaxIdleConns,
			ConnMaxLifetimeMin:  cfg.Azure.Synapse.ConnMaxLifetimeMin,
		})
		if err != nil {
			return nil, fmt.Errorf("failed to create Synapse engine: %w", err)
		}
		r.engines["azure"] = synapseEngine
	}

	// 初始化 DuckDB 引擎（作为 fallback）
	if cfg.DuckDB.Enabled {
		duckdbEngine, err := engine.NewDuckDBEngine(&engine.DuckDBConfig{
			S3AccessKey: cfg.DuckDB.S3AccessKey,
			S3SecretKey: cfg.DuckDB.S3SecretKey,
		})
		if err != nil {
			return nil, fmt.Errorf("failed to create DuckDB engine: %w", err)
		}
		r.engines["duckdb"] = duckdbEngine
	}

	return r, nil
}

// Route 根据云厂商选择查询引擎
func (r *Router) Route(vendor string) (engine.QueryEngine, error) {
	eng, ok := r.engines[vendor]
	if !ok {
		return nil, fmt.Errorf("no engine available for vendor: %s", vendor)
	}
	return eng, nil
}

// GetEngines 获取所有可用引擎
func (r *Router) GetEngines() map[string]engine.QueryEngine {
	return r.engines
}