#多租户与分片

// crates/summer-sharding/src/connector/connection.rs
#[derive(Clone)]
pub struct ShardingConnection {
    pub(crate) inner: Arc<ShardingConnectionInner>,
    pub(crate) hint_override: Option<ShardingHint>,
    pub(crate) access_context_override: Option<ShardingAccessContext>,
    pub(crate) tenant_override: Option<crate::tenant::TenantContext>,
}

pub(crate) struct ShardingConnectionInner {
    pub(crate) config: Arc<ShardingConfig>,
    pub(crate) pool: DataSourcePool,
    pub(crate) router: Box<dyn SqlRouter>,
    pub(crate) rewriter: Box<dyn SqlRewriter>,
    pub(crate) executor: Box<dyn Executor>,
    pub(crate) merger: Box<dyn ResultMerger>,
    pub(crate) tenant_metadata: Arc<TenantMetadataStore>,
    pub(crate) tenant_router: TenantRouter,
    /// SQL 改写插件注册表
    pub(crate) plugin_registry: OnceLock<PluginRegistry>,
}

// crates/summer-sharding/src/connector/connection.rs
#[async_trait::async_trait]
impl ConnectionTrait for ShardingConnection {
    async fn execute_raw(&self, stmt: Statement) -> Result<ExecResult, DbErr> {
        self.execute_with_raw(&self.inner.pool, stmt, false).await
    }

    async fn query_all_raw(&self, stmt: Statement) -> Result<Vec<QueryResult>, DbErr> {
        self.query_all_with_raw(&self.inner.pool, stmt, false).await
    }
    // query_one_raw 等同理
}

// crates/summer-sharding/src/connector/connection/exec.rs
pub(crate) async fn prepare_statement(/* ... */) -> Result<(...)> {
    // 1. sqlparser 解析 SQL，抽取表 / WHERE 条件 / hint / 租户
    let mut analysis = analyze_statement(stmt)?;
    analysis.tenant = overrides.tenant;

    // 2. 路由决策：单分片 / 跨分片 / 广播
    let mut plan = self.router.route(&analysis, force_primary)?;

    // 3. 按租户隔离级别微调路由（表名后缀、schema、数据源）
    self.apply_tenant_route(&mut plan, analysis.tenant.as_ref());

    // 4. 改写：在这里 sqlparser 介入
    let statements =
        self.rewriter
            .rewrite(stmt, &analysis, &plan, self.plugin_registry.get())?;
    // ...
}

// crates/summer-sharding/src/rewrite/mod.rs
for target in &plan.targets {
    // analysis.ast 是 analyze_statement() 用 sqlparser 解析出的 AST
    let mut parsed = analysis.ast.clone();

    // 逻辑表 → 物理表（改 AST，不拼字符串）
    for rewrite in &target.table_rewrites {
        rewrite_table_names(&mut parsed, &rewrite.logic_table, &rewrite.actual_table);
        apply_schema_rewrite(&mut parsed, &rewrite.logic_table, &rewrite.actual_table);
    }

    // 跨分片时放大 LIMIT
    if plan.targets.len() > 1 {
        inflate_limit_for_fanout(&mut parsed, plan.limit, plan.offset);
    }

    // 注入租户条件（改 WHERE 子句）
    if let Some(tenant) = analysis.tenant.as_ref() {
        apply_tenant_rewrite(&mut parsed, tenant, &self.config, &plan.logic_tables);
    }

    // 执行插件管道（见第三步）
    if let Some(registry) = plugin_registry {
        // ... 构造 SqlRewriteContext，registry.rewrite_all(&mut ctx)?
    }

    // 改写后的 AST 转回 SQL 字符串
    statement.sql = format_with_comments(&parsed.to_string(), &comments);
}

// crates/summer-sharding/src/sql_rewrite/plugin.rs
pub trait SqlRewritePlugin: Send + Sync + 'static {
    /// 插件名字（默认用 type_name）
    fn name(&self) -> &str { std::any::type_name::<Self>() }

    /// 执行顺序，越小越先执行。默认 100，内置用 0-99，用户插件建议 100+
    fn order(&self) -> i32 { 100 }

    /// 只对这些表生效。空 = 全部表。框架在调用 matches() 前自动检查
    fn tables(&self) -> &[QualifiedTableName] { &[] }

    /// 始终跳过这些表，优先级高于 tables()
    fn skip_tables(&self) -> &[QualifiedTableName] { &[] }

    /// 插件自身的匹配逻辑（操作类型、extensions 等）
    fn matches(&self, ctx: &SqlRewriteContext) -> bool;

    /// 改写 AST 或写注释
    fn rewrite(&self, ctx: &mut SqlRewriteContext) -> Result<()>;
}

// crates/summer-sharding/src/sql_rewrite/context.rs
pub struct SqlRewriteContext<'a> {
    pub statement: &'a mut AstStatement,  // sqlparser AST，可直接改
    pub operation: SqlOperation,          // Select/Insert/Update/Delete/Other
    pub tables: Vec<String>,              // SQL 涉及的所有表
    pub original_sql: &'a str,            // 原始 SQL（只读）
    pub extensions: &'a mut Extensions,   // 类型化上下文容器
    pub comments: Vec<String>,            // 写注释（附到最终 SQL）
}

// crates/summer-sharding/src/sql_rewrite/builtin/probe.rs
#[derive(Clone, Default)]
pub struct ProbePlugin {
    counter: Arc<AtomicUsize>,
}

impl SqlRewritePlugin for ProbePlugin {
    fn name(&self) -> &str { "probe" }
    fn matches(&self, _ctx: &SqlRewriteContext) -> bool { true }
    fn rewrite(&self, ctx: &mut SqlRewriteContext) -> Result<()> {
        let n = self.counter.fetch_add(1, Ordering::Relaxed) + 1;
        ctx.append_comment(&format!("probe={n}"));
        Ok(())
    }
}

// crates/app/src/main.rs
use summer_sharding::{ProbePlugin, SqlRewriteConfigurator, SummerShardingPlugin};

app.add_plugin(SummerShardingPlugin)
    // ... 其他插件
    .add_router(router::router())
    .sql_rewrite_configure(|registry| registry.register(ProbePlugin::new()))
    .run()
    .await;

// crates/summer-sharding/src/connector/connection/overrides.rs
pub fn with_tenant_context(&self, tenant: TenantContext) -> Self {
    let resolved = self.inner.tenant_router.resolve_context(tenant);
    let mut clone = self.clone();
    clone.tenant_override = Some(resolved);  // 只覆盖租户，共享底层连接池
    clone
}

use summer_sharding::{CurrentTenant, TenantShardingConnection};

async fn list_orders(
    CurrentTenant(tenant): CurrentTenant,                 // 当前租户上下文
    TenantShardingConnection(db): TenantShardingConnection, // 已绑定租户的连接
) -> ApiResult<Json<Vec<OrderVo>>> {
    // db 已绑定 tenant，这条查询会自动注入租户隔离
    let orders = order::Entity::find().all(&db).await?;
    Ok(Json(orders.into_iter().map(Into::into).collect()))
}

pub enum DataScope {
    Self_,            // creator_id = current_user_id
    Dept,             // dept_id = current_user.dept_id
    DeptAndChildren,  // dept_id IN (子树)
    Custom(Vec<i64>), // dept_id IN (...)
    All,              // 不加条件
}