module orm

const tx_callback_closed_err = 'transaction callback must not close the transaction explicitly'

enum TxKind {
    root
    savepoint
}

@[heap]
struct TxRootState {
mut:
    next_savepoint_id int  = 1
    active            bool = true
}

@[heap]
struct TxInner {
mut:
    conn           TransactionalConnection
    kind           TxKind
    active         bool = true
    savepoint_name string
    root_state     &TxRootState = unsafe { nil }
}

// Tx is an ORM transaction handle that can be used anywhere an orm.Connection is accepted.
pub struct Tx {
mut:
    inner &TxInner = unsafe { nil }
}

@[heap]
struct SavepointInner {
mut:
    conn   TransactionalConnection
    owner  &TxInner = unsafe { nil }
    name   string
    active bool = true
}

// Savepoint is a manual savepoint handle created from an active transaction.
pub struct Savepoint {
mut:
    inner &SavepointInner = unsafe { nil }
}

// begin starts a new ORM transaction on the provided connection.
pub fn begin(mut conn TransactionalConnection) !Tx {
    conn.orm_begin()!
    return Tx{
        inner: &TxInner{
            conn:       conn
            kind:       .root
            root_state: &TxRootState{}
        }
    }
}

// transaction runs a callback inside a transaction and commits or rolls back automatically.
pub fn transaction[T](mut conn TransactionalConnection, f fn (mut Tx) !T) !T {
    mut tx := begin(mut conn)!
    result := f(mut tx) or {
        callback_err := err
        if !tx.is_active() {
            return error(tx_callback_closed_err)
        }
        tx.rollback() or {
            return error('transaction callback failed: ${callback_err.msg()}; rollback failed: ${err.msg()}')
        }
        return callback_err
    }
    if !tx.is_active() {
        return error(tx_callback_closed_err)
    }
    tx.commit()!
    return result
}

// commit commits an active transaction.
pub fn (mut tx Tx) commit() ! {
    tx.ensure_active('commit')!
    match tx.inner.kind {
        .root {
            tx.inner.conn.orm_commit()!
            tx.inner.root_state.active = false
        }
        .savepoint {
            tx.inner.conn.orm_release_savepoint(tx.inner.savepoint_name)!
        }
    }

    tx.inner.active = false
}

// rollback rolls back an active transaction.
pub fn (mut tx Tx) rollback() ! {
    tx.ensure_active('rollback')!
    match tx.inner.kind {
        .root {
            tx.inner.conn.orm_rollback()!
            tx.inner.root_state.active = false
        }
        .savepoint {
            tx.inner.conn.orm_rollback_to(tx.inner.savepoint_name)!
            tx.inner.conn.orm_release_savepoint(tx.inner.savepoint_name)!
        }
    }

    tx.inner.active = false
}

// savepoint creates a manual savepoint inside an active transaction.
pub fn (mut tx Tx) savepoint() !Savepoint {
    tx.ensure_active('create a savepoint')!
    name := tx.next_savepoint_name()!
    tx.inner.conn.orm_savepoint(name)!
    return Savepoint{
        inner: &SavepointInner{
            conn:  tx.inner.conn
            owner: tx.inner
            name:  name
        }
    }
}

// transaction runs a nested transaction backed by a savepoint.
pub fn (mut tx Tx) transaction[T](f fn (mut Tx) !T) !T {
    tx.ensure_active('start a nested transaction')!
    name := tx.next_savepoint_name()!
    tx.inner.conn.orm_savepoint(name)!
    mut nested := Tx{
        inner: &TxInner{
            conn:           tx.inner.conn
            kind:           .savepoint
            savepoint_name: name
            root_state:     tx.inner.root_state
        }
    }
    result := f(mut nested) or {
        callback_err := err
        if !nested.is_active() {
            return error(tx_callback_closed_err)
        }
        nested.rollback() or {
            return error('transaction callback failed: ${callback_err.msg()}; rollback failed: ${err.msg()}')
        }
        return callback_err
    }
    if !nested.is_active() {
        return error(tx_callback_closed_err)
    }
    nested.commit()!
    return result
}

// rollback rolls back to the savepoint and releases it.
pub fn (mut sp Savepoint) rollback() ! {
    sp.ensure_active('rollback')!
    sp.inner.conn.orm_rollback_to(sp.inner.name)!
    sp.inner.conn.orm_release_savepoint(sp.inner.name)!
    sp.inner.active = false
}

// release releases the savepoint without rolling back.
pub fn (mut sp Savepoint) release() ! {
    sp.ensure_active('release')!
    sp.inner.conn.orm_release_savepoint(sp.inner.name)!
    sp.inner.active = false
}

fn (tx Tx) is_active() bool {
    return !isnil(tx.inner) && !isnil(tx.inner.root_state) && tx.inner.active
        && tx.inner.root_state.active
}

fn (tx Tx) ensure_active(action string) ! {
    if isnil(tx.inner) {
        return error('transaction is not initialized')
    }
    if !tx.inner.active {
        return error('transaction is inactive; cannot ${action}')
    }
}

fn (mut tx Tx) next_savepoint_name() !string {
    if isnil(tx.inner) || isnil(tx.inner.root_state) {
        return error('transaction is not initialized')
    }
    name := 'v_orm_sp_${tx.inner.root_state.next_savepoint_id}'
    tx.inner.root_state.next_savepoint_id++
    return name
}

fn (sp Savepoint) ensure_active(action string) ! {
    if isnil(sp.inner) {
        return error('savepoint is not initialized')
    }
    owner_tx := Tx{
        inner: sp.inner.owner
    }
    if !sp.inner.active || isnil(sp.inner.owner) || !owner_tx.is_active() {
        return error('savepoint is inactive; cannot ${action}')
    }
}

// select forwards ORM select queries through the active transaction.
pub fn (mut tx Tx) select(config SelectConfig, data QueryData, where QueryData) ![][]Primitive {
    tx.ensure_active('use the transaction')!
    return tx.inner.conn.select(config, data, where)
}

// insert forwards ORM insert queries through the active transaction.
pub fn (mut tx Tx) insert(table Table, data QueryData) ! {
    tx.ensure_active('use the transaction')!
    tx.inner.conn.insert(table, data)!
}

// update forwards ORM update queries through the active transaction.
pub fn (mut tx Tx) update(table Table, data QueryData, where QueryData) ! {
    tx.ensure_active('use the transaction')!
    tx.inner.conn.update(table, data, where)!
}

// delete forwards ORM delete queries through the active transaction.
pub fn (mut tx Tx) delete(table Table, where QueryData) ! {
    tx.ensure_active('use the transaction')!
    tx.inner.conn.delete(table, where)!
}

// create forwards ORM create queries through the active transaction.
pub fn (mut tx Tx) create(table Table, fields []TableField) ! {
    tx.ensure_active('use the transaction')!
    tx.inner.conn.create(table, fields)!
}

// drop forwards ORM drop queries through the active transaction.
pub fn (mut tx Tx) drop(table Table) ! {
    tx.ensure_active('use the transaction')!
    tx.inner.conn.drop(table)!
}

// last_id forwards the last inserted id through the wrapped connection.
pub fn (mut tx Tx) last_id() int {
    if isnil(tx.inner) {
        return 0
    }
    return tx.inner.conn.last_id()
}