// orm_scope_middleware.v - ORM middleware pattern demo
//
// Shows how middleware manages DataScope (multi-tenant) transparently.
// Business code only changes acquire() -> pool_acquire_scoped().
//
// Run: v run orm_scope_middleware.v

module main

import db.sqlite
import orm

// =============================================================================
// Model
// =============================================================================

@[table: 'sys_users']
struct SysUser {
    id        int @[primary; sql: serial]
    name      string
    tenant_id int
    org_id    int
}

// =============================================================================
// Request context
// =============================================================================

struct UserInfo {
mut:
    role      string
    tenant_id int
}

pub struct Context {
pub mut:
    user   UserInfo
    dbpool &DatabasePool
}

// =============================================================================
// Connection pool (SQLite version)
// In real projects, use adapter.dbpool.DatabasePoolable
// =============================================================================

pub struct DatabasePool {
    conn &sqlite.DB
}

pub fn new_pool() &DatabasePool {
    mut db := sqlite.connect(':memory:') or { panic(err) }
    return &DatabasePool{
        conn: &db
    }
}

// acquire gets a connection from pool
pub fn (mut p DatabasePool) acquire() !&sqlite.DB {
    return p.conn
}

// release returns a connection to pool
pub fn (mut p DatabasePool) release(conn &sqlite.DB) ! {
    // no-op for single-connection SQLite
    // real pool: p.inner.put(conn)!
}

// =============================================================================
// Middleware layer -- pool_acquire_scoped
//
// Responsibilities:
//   1. Acquire connection from pool
//   2. Create orm.DB with DataScope injected
//   3. Skip scope filters based on user role
//   4. Return configured orm.DB
//
// Business code just replaces acquire() -> pool_acquire_scoped()
// =============================================================================

pub fn pool_acquire_scoped(mut ctx Context) !(orm.DB, &sqlite.DB) {
    // 1. acquire raw connection
    raw_conn := ctx.dbpool.acquire()!

    // 2. create base orm.DB with tenant scope
    base_db := orm.new_db(raw_conn, orm.DataScope{
        filters: [
            orm.QueryFilter{
                field: 'tenant_id'
                value: orm.Primitive(ctx.user.tenant_id)
                mode:  .dynamic
            },
        ]
    })

    // 3. skip scope filters by role
    mut scoped_db := base_db
    match ctx.user.role {
        'admin' {
            scoped_db = scoped_db.unscoped()
        }
        'manager' {
            scoped_db = scoped_db.unscoped('org_id')
        }
        'normal' {}
        else {}
    }

    // 4. return scoped DB
    return scoped_db, raw_conn
}

// =============================================================================
// Business layer -- Repository
//
// No awareness of DataScope at all.
// Only change: acquire() -> pool_acquire_scoped()
// =============================================================================

fn get_users(mut ctx Context) ![]SysUser {
    db, conn := pool_acquire_scoped(mut ctx)!
    defer {
        ctx.dbpool.release(conn) or {}
    }

    return sql db {
        select from SysUser
    }!
}

fn get_user_by_name(mut ctx Context, name string) ![]SysUser {
    db, conn := pool_acquire_scoped(mut ctx)!
    defer {
        ctx.dbpool.release(conn) or {}
    }

    return sql db {
        select from SysUser where name == name
    }!
}

fn count_users(mut ctx Context) !int {
    db, conn := pool_acquire_scoped(mut ctx)!
    defer {
        ctx.dbpool.release(conn) or {}
    }

    return sql db {
        select count from SysUser
    }!
}

// =============================================================================
// Demo
// =============================================================================

fn main() {
    // setup
    mut pool := new_pool()
    db := pool.conn

    sql db {
        create table SysUser
    }!

    users := [
        SysUser{
            name:      'Alice'
            tenant_id: 1
            org_id:    10
        },
        SysUser{
            name:      'Bob'
            tenant_id: 1
            org_id:    20
        },
        SysUser{
            name:      'Charlie'
            tenant_id: 2
            org_id:    10
        },
        SysUser{
            name:      'Diana'
            tenant_id: 2
            org_id:    20
        },
    ]
    for u in users {
        sql db {
            insert u into SysUser
        }!
    }

    println('=== test data ===')
    println('Alice  : tenant=1, org=10')
    println('Bob    : tenant=1, org=20')
    println('Charlie: tenant=2, org=10')
    println('Diana  : tenant=2, org=20')

    mut ctx := Context{
        user:   UserInfo{
            role:      'normal'
            tenant_id: 1
        }
        dbpool: pool
    }

    // scenario 1: normal user, tenant=1
    println('\n--- normal user (tenant=1) ---')
    users1 := get_users(mut ctx) or { panic(err) }
    println('got ${users1.len} rows:')
    for u in users1 {
        println('  - ${u.name} (tenant=${u.tenant_id})')
    }

    // scenario 2: manager, tenant=1 (skip org_id, no effect since only tenant_id scope)
    println('\n--- manager user (tenant=1) ---')
    ctx.user.role = 'manager'

    users2 := get_users(mut ctx) or { panic(err) }
    println('got ${users2.len} rows:')
    for u in users2 {
        println('  - ${u.name} (tenant=${u.tenant_id})')
    }

    // scenario 3: admin (skip all scopes)
    println('\n--- admin user (skip all scopes) ---')
    ctx.user.role = 'admin'

    users3 := get_users(mut ctx) or { panic(err) }
    println('got ${users3.len} rows:')
    for u in users3 {
        println('  - ${u.name} (tenant=${u.tenant_id})')
    }

    // scenario 4: normal user, tenant=2
    println('\n--- normal user (tenant=2) ---')
    ctx.user.role = 'normal'
    ctx.user.tenant_id = 2

    users4 := get_users(mut ctx) or { panic(err) }
    println('got ${users4.len} rows:')
    for u in users4 {
        println('  - ${u.name} (tenant=${u.tenant_id})')
    }

    // scenario 5: get_user_by_name
    println('\n--- get_user_by_name (admin, name=Alice) ---')
    ctx.user.role = 'admin'
    users_by_name := get_user_by_name(mut ctx, 'Alice') or { panic(err) }
    println('got ${users_by_name.len} rows:')
    for u in users_by_name {
        println('  - ${u.name} (tenant=${u.tenant_id})')
    }

    // scenario 6: count
    println('\n--- count (admin) ---')
    total := count_users(mut ctx) or { panic(err) }
    println('total: ${total}')

    // assertions
    println('\n=== assertions ===')
    assert users1.len == 2 // normal/tenant=1: Alice + Bob
    assert users2.len == 2 // manager/tenant=1: Alice + Bob
    assert users3.len == 4 // admin: all 4
    assert users4.len == 2 // normal/tenant=2: Charlie + Diana
    assert users_by_name.len == 1 // admin: Alice
    assert total == 4 // admin: all 4
    println('all passed ✓')
}