import { LogAndError } from '@birbal/common-utilities/dist/error';
import { VirtualStateMachine } from '../../State/Virtual/state-machine';
import { VirtualRegistryModel, IVirtualRegistry } from '../../Model/Virtual/Meta/registry';

export abstract class VirtualBaseResource {
    protected DATABASE_NAME: string;
    protected SUPER_SECRET: string;

    protected abstract ID_TYPE: string;

    constructor(dbName: string, superSecret: string) {
        this.DATABASE_NAME = dbName;
        this.SUPER_SECRET = superSecret;
    }

    async makeEntry(userId: string, dbTxnId?: string): Promise<[string, string]> {
        if (!userId) {
            throw new LogAndError("Invalid user id in utility profile ");
        }

        if(!this.DATABASE_NAME) {
            throw new LogAndError("Invalid db name in utility profile");
        }

        try {
            // Create Virtual Entry
            let virtualSM = new VirtualStateMachine(this.DATABASE_NAME);
            let virtualId = await virtualSM.create(userId, this.ID_TYPE, dbTxnId);

            // Submit the entry for verification
            await virtualSM.submit(virtualId, dbTxnId);

            let status = await virtualSM.getCurrentState(virtualId, dbTxnId);
            return [virtualId, status];
        } catch (e) {
            throw e;
        }
    }

    async updateStatus(
        virtualId: string
        , action: 'remove'|'reject'|'approve'|'expire'|'revoke'
        , dbTxnId?: string
    ): Promise<[string, string]> {
        if (!virtualId || !action) {
            throw new LogAndError("Invalid virtual id or action in utility profile");
        }

        if (!this.SUPER_SECRET || !this.DATABASE_NAME) {
            throw new LogAndError("Invalid db name or super secret in utility profile");
        }

        try {
            let regModel = new VirtualRegistryModel(this.DATABASE_NAME);
            await regModel.defineSchema();

            let iReg: IVirtualRegistry|undefined;
            if(dbTxnId) {
                let localDoc = await regModel.findLocal(virtualId, dbTxnId);
                if (localDoc && localDoc.body) {
                    iReg = localDoc.body;
                }
            }

            if (!iReg) {
                let registry = await regModel.find(virtualId, dbTxnId);
                iReg = regModel.getDataModel(registry);    
            }
            
            if (!iReg || !iReg.registry || !iReg.registry.userRef) {
                throw new LogAndError("Invalid virtual details in utility profile");
            }
            let userId = iReg.registry.userRef;
            let virtualSM = new VirtualStateMachine(this.DATABASE_NAME);


            switch (action) {
                case 'remove':
                {
                    await virtualSM.removed(virtualId, dbTxnId);
                    break;
                }
                case 'reject':
                {
                    await virtualSM.rejected(virtualId, dbTxnId);
                    break;
                }
                case 'approve':
                {
                    await virtualSM.approve(virtualId, dbTxnId);
                    break;
                }
                case 'expire':
                {
                    await virtualSM.expire(virtualId, dbTxnId);
                    break;
                }
                case 'revoke':
                {
                    await virtualSM.revoke(virtualId, dbTxnId);
                    break;
                }
                default:
                    break;
            }

            let status = await virtualSM.getCurrentState(virtualId, dbTxnId);
            return [status, userId];
        } catch (e) {
            throw e;
        }
    }
}