import { Injectable } from '@nestjs/common';
import { Checkout } from 'src/domain/entity/tables/pccaixa.entity';
import { Connection } from 'typeorm';
import { Store } from '../../domain/entity/tables/pcfilial.entity';
import { Pcempr } from '../../domain/entity/tables/pcempr.entity';
import { connectionOptions } from 'src/configs/typeorm.config';

@Injectable()
export class ListsService {

    async GetStoreAll(): Promise<Store[]> {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        try {
            const sql = `SELECT PCFILIAL.CODIGO as "id", ` +
                `       PCFILIAL.RAZAOSOCIAL as "name",  ` +
                `       PCFILIAL.CODIGO|| ' - '|| PCFILIAL.FANTASIA as "shortName"   ` +
                `  FROM PCFILIAL  ` +
                ` WHERE PCFILIAL.CODIGO <> '99'  ` +
                ` ORDER BY PCFILIAL.CODIGO `;
            const stores = await queryRunner.query(sql);
            return stores as Store[];
        } catch (error) {
            console.log(error);
            throw error;
        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

    async GetStoreByUser(idUser: number): Promise<Store[]> {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        const sql = `SELECT PCFILIAL.CODIGO as "id", ` +
            `       PCFILIAL.RAZAOSOCIAL as "name",  ` +
            `       PCFILIAL.CODIGO|| ' - '|| PCFILIAL.FANTASIA as "shortName"   ` +
            `  FROM PCFILIAL  `;
        const whereByUser = " WHERE PCFILIAL.CODIGO <> '99' AND " +
            " ((PCFILIAL.CODIGO IN ( SELECT PCLIB.CODIGOA FROM PCLIB WHERE PCLIB.CODTABELA = 1 AND PCLIB.CODFUNC = :iduser )) OR " +
            "        (EXISTS(SELECT PCLIB.CODIGOA FROM PCLIB WHERE PCLIB.CODTABELA = 1 AND PCLIB.CODFUNC = :iduser AND PCLIB.CODIGOA = '99')) ) ";

        const orderBy = ` ORDER BY PCFILIAL.CODIGO`
        try {
            const stores = await queryRunner.query(sql + whereByUser + orderBy, [idUser]);
            return stores as Store[];
        } catch (error) {
            console.log(error);
            throw error;
        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

    async GetCheckout(idStore: string): Promise<Checkout[]> {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        try {
            const checkouts = await queryRunner.manager
                .getRepository(Checkout)
                .createQueryBuilder('pccaixa')
                .where("\"pccaixa\".CODFILIAL = :idStore", { idStore: idStore })
                .orderBy("\"pccaixa\".NUMCAIXA")
                .getMany();
            return checkouts;
        } catch (error) {
            console.log(error);
            throw error;
        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

    async GetUser(idStore: string): Promise<Pcempr[]> {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        try {
            const checkouts = await queryRunner.manager
                .getRepository(Pcempr)
                .createQueryBuilder('pcempr')
                .select("\"pcempr\".matricula as \"id\", \"pcempr\".nome as \"name\", \"pcempr\".email as \"email\", \"pcempr\".usuariobd as \"smallName\"")
                .where("\"pcempr\".CODFILIAL = :idStore", { idStore: idStore })
                .orderBy("\"pcempr\".NOME")
                .getRawMany();
            return checkouts;
        } catch (error) {
            console.log(error);
            throw error;
        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

    async GetPaymentPlan(billingId: string, clientId: string) {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        try {
            const sql = `SELECT PCPLPAG.CODPLPAG as "codplpag", PCPLPAG.DESCRICAO as "descricao",  
                                NVL(PCPLPAG.NUMDIAS,0) as "numdias" 
                           FROM PCPLPAG, PCCLIENT, PCPLPAG PLANO_CLI   
                          WHERE PCCLIENT.CODCLI = :CODCLI
                            AND PCCLIENT.CODPLPAG = PLANO_CLI.CODPLPAG (+)
                            AND PCPLPAG.NUMDIAS <= NVL(PLANO_CLI.NUMDIAS,9999) 
                            AND EXISTS(SELECT PCCOBPLPAG.CODCOB FROM PCCOBPLPAG 
                                                    WHERE PCCOBPLPAG.CODPLPAG = PCPLPAG.CODPLPAG 
                                                                AND PCCOBPLPAG.CODCOB = :CODCOB ) 
                          ORDER BY PCPLPAG.DESCRICAO`;

            const paymentPlans = await queryRunner.query(sql, [clientId, billingId]);
            return paymentPlans;
        } catch (error) {
            throw error;
        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

    async GetBilling(clienteId: number) {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        try {
            const sql = ' SELECT PCCOB.CODCOB as "codcob", PCCOB.CODCOB ||\' - \'||PCCOB.COBRANCA as "cobranca" ' +
                '   FROM PCCOB ' +
                '  WHERE NVL(PCCOB.enviacobrancafv, \'N\') = \'S\'  ' +
                '               AND ( ( NOT EXISTS(SELECT PCCOBCLI.CODCOB FROM PCCOBCLI WHERE PCCOBCLI.CODCLI = :CODCLI  ) AND  ' +
                '                   ( PCCOB.NIVELVENDA >= ( SELECT C.NIVELVENDA FROM PCCLIENT, PCCOB C ' +
                '                                            WHERE PCCLIENT.CODCLI = :CODCLI AND PCCLIENT.CODCOB = C.CODCOB ) ) ) OR ' +
                '                      EXISTS(SELECT PCCOBCLI.CODCOB FROM PCCOBCLI WHERE PCCOBCLI.CODCLI = :CODCLI AND PCCOBCLI.CODCOB = PCCOB.CODCOB ) ) ' +
                ' ORDER BY PCCOB.CODCOB';
            const billings = await queryRunner.query(sql, [clienteId]);
            return billings;
        } catch (error) {
            throw error;
        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

    async GetPartners() {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        try {
            const sql = '  SELECT  ESTPARCEIRO.ID as "id" ' +
                '         ,REGEXP_REPLACE(ESTPARCEIRO.CPF, \'[^0-9]\',\'\') || \' - \' ||ESTPARCEIRO.NOME as "name"  ' +
                '    FROM ESTPARCEIRO ' +
                '   WHERE 1 = 1 ';
            const partners = await queryRunner.manager
                .query(sql);
            return partners;
        } catch (error) {
            throw error;
        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

    async GetPreCustomer(idCart: string) {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        try {
            const sql = '  select CPF as "document"     ' +
                '        ,NOME as "name"        ' +
                '        ,TELEFONE as "phone"   ' +
                '        ,IDCART as "idCart"    ' +
                '    from estvendaprecliente    ' +
                '   where IDCART = :idcart      ';
            console.log(idCart);
            const preCustomer = await queryRunner
                .query(sql, [idCart]);
            console.log(JSON.stringify(preCustomer));
            return preCustomer[0];
        } catch (error) {
            throw error;
        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

    async GetPlaces() {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        try {
            const sql = '  SELECT  PCPRACA.CODPRACA as "id" ' +
                '         ,PCPRACA.PRACA as "name"  ' +
                '    FROM PCPRACA ' +
                '   WHERE 1 = 1';
            const places = await queryRunner.manager
                .query(sql);
            return places;
        } catch (error) {
            throw error;
        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

    async GetStorePlaces() {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        try {
            const sql = '  SELECT  PCPRACA.CODPRACA as "id" ' +
                '         ,PCPRACA.PRACA as "name"  ' +
                '    FROM PCPRACA ' +
                '   WHERE PCPRACA.CODPRACAPRINCIPAL = 1004';
            const places = await queryRunner.manager
                .query(sql);
            return places;
        } catch (error) {
            throw error;
        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

    async GetRamo() {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        try {
            const sql = '  SELECT  PCATIVI.CODATIV as "id" ' +
                '         ,PCATIVI.RAMO as "name"  ' +
                '    FROM PCATIVI ' +
                '   WHERE 1 = 1 ' +
                ' ORDER BY PCATIVI.RAMO';
            const ramos = await queryRunner.manager
                .query(sql);
            return ramos;
        } catch (error) {
            throw error;
        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

    async GetStates(state: string) {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        try {
            const sql = '  SELECT  PCESTADO.ESTADO as "name" FROM PCESTADO' +
                '   WHERE  PCESTADO.UF = :1';
            const states = await queryRunner.manager
                .query(sql, [state]);
            return states[0].name;
        } catch (error) {
            throw error;
        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

    async getSupervisores() {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        try {
            const sql = `SELECT PCSUPERV.CODSUPERVISOR as "supervisorId" 
                               ,PCSUPERV.NOME          as "name"
                           FROM PCSUPERV
                          WHERE PCSUPERV.dtdemissao IS NULL`;
            const supervisores = await queryRunner.manager
                .query(sql);
            return supervisores;
        } catch (error) {
            throw error;
        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

}