import { Injectable, BadRequestException } from '@nestjs/common';
import { CodeDTO } from '../../user/models/code.dto';
import { RedemptionCode } from '../../entity/RedemptionCode';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository, Code } from 'typeorm';
import { RedemptionRecord } from '../../entity/RedemptionRecord';
import { User } from '../../entity/User';
import { Status } from '../../common/enum/status';
import { CheckCodeDTO } from '../../user/models/check-code.dto';
import { ShowMessageDTO } from '../../user/models/show-message.dto';
import { AddPrizeToCodeDTO } from '../../user/models/add-prize-code.dto';
@Injectable()
export class UserService {

    public constructor(
        @InjectRepository(RedemptionCode) private readonly redemptionCodeRepo: Repository<RedemptionCode>,
        @InjectRepository(RedemptionRecord) private readonly redemptionRecordRepo: Repository<RedemptionRecord>,
        @InjectRepository(User) private readonly userRepo: Repository<User>,
    ) { }

    public async checkForValidCode(code: CheckCodeDTO): Promise<RedemptionCode | RedemptionRecord[]> {
        const redemptionCode = await this.checkIfCodeIsValid(code.redemptionCode);
        if (!redemptionCode) {
            throw new BadRequestException(`Sorry, your code is invalid!`);
        }

        let redemptionRecordExist = await this.redemptionRecordRepo.find({
            relations: ['outlet', 'customer'],
            where: {
                redemptionCode,
            },
        });

        // tslint:disable-next-line: max-line-length
        redemptionRecordExist = redemptionRecordExist.filter(x => ((x.status === Status.Redeemed) || (x.status === Status.Declined))); // checks if status is already redeemed
        if (redemptionRecordExist.length) {
            return redemptionRecordExist;
        }

        return redemptionCode;
    }

    public async markCode(code: CodeDTO, me: User): Promise<ShowMessageDTO> {
        const redemptionCode = await this.checkIfCodeIsValid(code.redemptionCode);

        if (!redemptionCode) {
            throw new BadRequestException('Invalid code!');
        }

        const redemptionRecords = await redemptionCode.redemptionRecords;
        const checkIfCodeIsRedeemed = redemptionRecords.filter(x => x.status === Status.Redeemed);

        if (checkIfCodeIsRedeemed.length) {
            code.status = Status.Declined;
        }

        const record = await this.setRedemptionRecord(me, code);
        const arrFromRecords = await redemptionCode.redemptionRecords;
        const userRedemptionRecords = await me.redemptionRecords;

        arrFromRecords.push(record);
        userRedemptionRecords.push(record);
        record.redemptionCode = Promise.resolve(redemptionCode);
        me.redemptionRecords = Promise.resolve(userRedemptionRecords);
        redemptionCode.redemptionRecords = Promise.resolve(arrFromRecords);

        await this.userRepo.save(me);
        await this.redemptionRecordRepo.save(redemptionRecords);
        await this.redemptionCodeRepo.save(redemptionCode);

        return { message: 'Success' };
    }

    public async addPrizeToRedemptionCode(code: AddPrizeToCodeDTO): Promise<ShowMessageDTO> {
        const findCode = await this.redemptionCodeRepo.findOne({
            where: {
                redemptionCode: code.redemptionCode,
            },
        });

        findCode.itemPrize = code.itemPrize;

        await this.redemptionCodeRepo.save(findCode);
        return { message: 'success' };
    }

    public async setRedemptionRecord(me: User, code: CodeDTO): Promise<RedemptionRecord> {
        const setRecord = new RedemptionRecord();
        setRecord.outlet = Promise.resolve(me.outlet);
        setRecord.status = code.status;
        setRecord.customer = Promise.resolve((await me.outlet).customer);
        setRecord.user = Promise.resolve(me);
        return setRecord;
    }

    public async checkIfCodeIsValid(code: string): Promise<RedemptionCode> {
        return await this.redemptionCodeRepo.findOne({
            where: {
                redemptionCode: code,
            },
        });
    }

    public async reportRedemptionCode(code: CheckCodeDTO, me: User): Promise<ShowMessageDTO> {
        const findCode = await this.redemptionCodeRepo.findOne({
            where: {
                redemptionCode: code.redemptionCode,
            },
        });

        findCode.reportedCode = true;
        findCode.reportedBy = me.username;

        await this.redemptionCodeRepo.save(findCode);
        return { message: 'success' };
    }

    public async getUserActivity(me) {
        const myRecords = await this.redemptionRecordRepo.find({
            where: {
                user: me,
            },
            relations: ['redemptionCode', 'outlet'],
        });
        const getRecordsForMyOutlet = myRecords.filter(x => (x as any).__outlet__.id === me.outlet.id).map(x => {
            (x as any).__outlet__ = me.outlet;
            return x;
        });

        return getRecordsForMyOutlet;
    }
}