import currency from 'currency.js';
import {pito} from 'pito';
import {AdminExpensesKind, AdminExpensesType, unpackingAdminExpensesKind} from '../enums';

export const AdminExpensesDefine = pito.Uobj('type')
    .case(AdminExpensesType.Discussion, ({
        price: pito.Num(),
        kinds: pito.Arr(pito.Enums(AdminExpensesKind)),
    }))
    .case(AdminExpensesType.NoFee, ({}))
    .end();
export type AdminExpensesDefine = pito.Type<typeof AdminExpensesDefine>;
export namespace AdminExpenses {
    // TODO : 타입 체크 할 것.
    export function wrap(type: AdminExpensesType, price: currency | string | number | null | undefined, kinds: AdminExpensesKind[] | string | bigint | null | undefined): AdminExpensesDefine {
        let p: number | undefined;
        if (price instanceof currency) {
            p = price.intValue;
        } else if (typeof price === 'string') {
            p = parseInt(price);
            if (p === NaN) {
                throw new Error(`price not nan , parseInt(${price})`);
            }
        } else if (typeof price === 'number') {
            p = price;
        } else {
            p = undefined;
        }
        let k: AdminExpensesKind[] | undefined;
        switch (typeof kinds) {
        case 'bigint':
            k = unpackingAdminExpensesKind(kinds);
            break;
        case 'string':
            k = unpackingAdminExpensesKind(BigInt(kinds));
            break;
        default:
            k = kinds ?? undefined;
            break;
        }
        switch (type) {
        case AdminExpensesType.Discussion:
            if (p === undefined || k === undefined) {
                throw new Error(`AdminExpensesType.Discussion not allow undefined price or kinds`);
            }
            return {
                type : AdminExpensesType.Discussion,
                price: p,
                kinds: k,
            };
        case AdminExpensesType.NoFee:
            return {
                type: AdminExpensesType.NoFee,
            };
        }
    }
    export function unwrap(def: AdminExpensesDefine): { type: AdminExpensesType, price?: number, kinds?: AdminExpensesKind[] } {
        switch (def.type) {
        case AdminExpensesType.Discussion:
            return {
                type : AdminExpensesType.Discussion,
                price: def.price,
                kinds: def.kinds,
            };
        default:
            return {
                type: def.type,
            };
        }
    }
    export function unwrapUndef(def: AdminExpensesDefine | undefined): { type?: AdminExpensesType, price?: number, kinds?: AdminExpensesKind[] } {
        if (def === undefined) {
            return {};
        }
        return unwrap(def);
    }
}