import { MysqlError } from "mysql"
import {IDao, ITransaction} from "../../type/interface"
import {PojoType} from "../../type/type"
import DecorateRegistCenter from "../DecorateRegistCenter"
import InstanceBuilder from "../instance/InstanceBuilder"

export default class TransactionInterceptor{
    private instance: PojoType
    private instanceBuilder: InstanceBuilder

    constructor(instance: PojoType, instanceBuilder: InstanceBuilder){
        this.instance = instance
        this.instanceBuilder = instanceBuilder
        this.init()
    }

    public init(): void{   
    }

    public async handler(target = Function, ctx = {}, args = [], method: Function = function(){}): Promise<PojoType>{
        const {transactions = <Array<ITransaction>>[]} = DecorateRegistCenter
        const transaction = transactions.find(({methodName, cost}: ITransaction) => {
            return methodName === method.name && cost === this.instance.meta.component.cost
        })
        if(transaction){
            const {component} = this.instance.meta
            const id = String(Math.random() + (+ new Date()))
            const fakeInstance = this.instanceBuilder.createInstance(component, true, id)
            const dao = this.instanceBuilder.getFakeComponentFromCache(id)
            const conn = await dao.getConnection();
            dao.setAlive()
            return new Promise((resolve, reject) => {
                conn.beginTransaction(async (err: MysqlError) => {
                    if(!err){
                        let process = null
                        try{
                            process = await Reflect.apply(target, fakeInstance, args)
                            conn.commit()
                            resolve({
                                instance: fakeInstance,
                                transaction: true,
                                process
                            })
                        }catch(exception){
                            reject(exception)
                            conn.rollback()
                        }finally{
                            conn.release()
                        }
                    }
                })
            })
        }
        return {
            instance: ctx,
            transaction: false
        }
    }
}