import { DataRangeRule, Injectable, InjectionToken, PlainPro, Provider } from "@notadd/core";
import { Between, In } from 'typeorm';
import { SelectQueryBuilder } from '../typeorm-native';

export interface BaseData {
    title: string;
}
export const DATA_RANGE_RULE = new InjectionToken<DataRangeRule>(`@ganker/permission DATA_RANGE_RULE`)
export const DATA_RANGE_DATA = new InjectionToken<BaseData>(`@ganker/permission DATA_RANGE_DATA`)

@Injectable()
export class CurrentUidData implements BaseData {
    @PlainPro()
    title: string = `当前用户`
}
@Injectable()
export class CurrentCodeData implements BaseData {
    @PlainPro()
    title: string = `当前人员编号`
}
@Injectable()
export class CurrentDepartmentIdData implements BaseData {
    @PlainPro()
    title: string = `当前部门`
}
@Injectable()
export class CurrentDepartmentAndChildrenIdsData implements BaseData {
    @PlainPro()
    title: string = `当前部门及子部门`
}
@Injectable()
export class CurrentRoleIdsData implements BaseData {
    @PlainPro()
    title: string = `当前角色`
}
@Injectable()
export class CurrentStationIdsData implements BaseData {
    @PlainPro()
    title: string = `当前岗位`
}
@Injectable()
export class CurrentRoleGroupIdsData implements BaseData {
    @PlainPro()
    title: string = `当前角色组`
}

@Injectable()
export class CurrentDomainIdData implements BaseData {
    @PlainPro()
    title: string = `当前域`
}
@Injectable()
export class DesignEqualData implements BaseData {
    @PlainPro()
    title: string = `自定义`

    @PlainPro()
    value: string = ``;
}
@Injectable()
export class DesignInData implements BaseData {
    @PlainPro()
    title: string = `自定义`

    @PlainPro()
    value: string[] = [];
}
@Injectable()
export class DesignBeginData implements BaseData {
    @PlainPro()
    title: string = `自定义`

    @PlainPro()
    value: [string, string] = [``, ``];
}
/**
 * 等于
 */
@Injectable()
export class EqualDataRangeRule implements DataRangeRule {

    @PlainPro()
    title: string = `是`
    @PlainPro({
        isClass: true
    })
    list: BaseData[] = [
        new CurrentUidData(), 
        new CurrentDepartmentIdData(), 
        new DesignEqualData(),
        new CurrentCodeData()
    ];
    @PlainPro({
        isClass: true
    })
    value: any;

    getValue(columnType: any,current: any): any {
        if (this.value instanceof CurrentUidData) {
            return current.id;
        } else if (this.value instanceof CurrentDepartmentIdData) {
            return current.departmentId;
        } else if (this.value instanceof DesignEqualData) {
            return columnType(this.value.value);
        } else if (this.value instanceof CurrentCodeData){
            return current.code || 'null';
        } else {
            throw new Error('EqualDataRangeRule value type error');
        }
    }

    handleBuilder(columnName: string, columnType: any, current: any, qb: SelectQueryBuilder<any>): void {
        const val = this.getValue(columnType,current);
        qb.andWhere(`${qb.alias}.${columnName} = :${columnName}`, {
            [`${columnName}`]: val
        })
    }

    handleWhere(columnType: any, current: any) {
        const val = this.getValue(columnType,current);
        return val;
    }
    
}
/**
 * 包含
 */
@Injectable()
export class InDataRangeRule implements DataRangeRule {

    @PlainPro()
    title: string = `包含在`;

    @PlainPro({
        isClass: true
    })
    list: BaseData[] = [
        new CurrentDepartmentAndChildrenIdsData(), 
        new CurrentRoleGroupIdsData(),
        new CurrentStationIdsData(),
        new CurrentRoleIdsData(),
        new DesignInData()
    ];
    @PlainPro({
        isClass: true
    })
    value: any;

    handleBuilder(columnName: string, columnType: any, current: any, qb: SelectQueryBuilder<any>): void {
        const val: any[] = this.getValue(columnType,current);
        qb.andWhere(`${qb.alias}.${columnName} in :${columnName}`, {
            [`${columnName}`]: typeof val[0] === 'string'?  `('${val.join(`','`)}')`: `(${val.join(',')})`
        })
    }

    handleWhere(columnType: any, current: any) {
        const val: any[] = this.getValue(columnType,current);
        return In(val);
    }

    getValue(columnType: any, current: any) {
        let val: any;
        if (this.value instanceof CurrentDepartmentAndChildrenIdsData) {
            val = current.departmentIds;
        } else if (this.value instanceof CurrentRoleGroupIdsData) {
            val = current.roleGroupIds;
        } else if (this.value instanceof CurrentRoleIdsData) {
            val = current.roleIds;
        } else if (this.value instanceof CurrentStationIdsData) {
            val = current.stationIds;
        } else if (this.value instanceof DesignInData) {
            val = this.value.value;
            if (columnType !== String) {
                val = val.map((it: any) => columnType(it));
            }
        } else {
            throw new Error('InDataRangeRule value type error');
        }
        if (val.length < 1) {
            if (columnType === String) {
                val.push('null value');
            } else if (columnType === Number) {
                val.push(0);
            }
        }
        return val;
    }
    
}

@Injectable()
export class BeginEndDataRangeRule implements DataRangeRule {

    @PlainPro()
    title: string = `在`
    @PlainPro({ isClass: true })
    list: BaseData[] = [new DesignBeginData()];
    @PlainPro({ isClass: true })
    value: any;

    handleBuilder(columnName: string, columnType: any, current: any, qb: SelectQueryBuilder<any>): void {
        const value = this.value as DesignBeginData;
        const begin = columnType(value.value[0])
        const end = columnType(value.value[1])
        qb.andWhere(`${qb.alias}.${columnName} Between :begin AND :end`, {
            begin, end
        })
    }

    handleWhere(columnType: any, current: any) {
        const value = this.value as DesignBeginData;
        const begin = columnType(value.value[0])
        const end = columnType(value.value[1])
        return Between(begin,end);
    }
}

export const dataRangeProviders: Provider[] = [
    CurrentUidData,
    CurrentDepartmentIdData,
    DesignEqualData,
    {
        provide: DATA_RANGE_RULE,
        useClass: EqualDataRangeRule,
        multi: true
    }, {
        provide: DATA_RANGE_RULE,
        useClass: BeginEndDataRangeRule,
        multi: true
    }, {
        provide: DATA_RANGE_RULE,
        useClass: InDataRangeRule,
        multi: true
    }]