import { HttpService, Injectable, Inject, forwardRef } from '@nestjs/common';
import { Order, RoleType } from 'common/constants';
import { PartnerEntity } from 'modules/partner/entities';
import { PageMetaDto } from 'common/dtos';
import { PartnerRepository } from 'modules/partner/repositories'
import {
    CreateFailedException,
    DeleteFailedException,
    EmailAddressExistException,
  } from 'exceptions';

import {
    PartnerUpdateDto,
    PartnerRegisterDto,
    PartnersPageDto,
    PartnersPageOptionsDto,
  } from 'modules/partner/dtos';
import { UserDto } from 'modules/user/dtos';

@Injectable()
export class PartnerService {
    constructor(
        private readonly _partnerRepository: PartnerRepository,
        private readonly _httpService: HttpService,
    ) {}
    private _partnerToResponseObject(partner: PartnerEntity): any {
      const responseObject: any = {
        ...partner.toDto(),
        adminUser: partner.user.length ? partner.user.map( user => user.toDto()) : [],
      };
      return responseObject;
    }

    public async getPartner(
        options: Partial<{ uuid: string; name: string; email:string }>,
      ): Promise<PartnerEntity | undefined> {
        const queryBuilder = this._partnerRepository.createQueryBuilder(
          'partner',
        );
    
        if (options.uuid) {
          //@todo call admin user
          queryBuilder
          .leftJoinAndSelect("partner.user", "user")
          .leftJoinAndSelect("user.userAuth", "userAuth")
          .orWhere('userAuth.role = :admin_role',{
            admin_role: RoleType.P_ADMIN
          })
          .orWhere('partner.uuid = :uuid', {
            uuid: options.uuid,
          });
        }
    
        if (options.name) {
          queryBuilder.orWhere('partner.name = :name', {
            name: options.name,
          });
        }
        if (options.email) {
          queryBuilder.orWhere('partner.email = :email', {
            email: options.email,
          });
        }
        const result = await queryBuilder.getOne()
        if(result) {
          return this._partnerToResponseObject(result);
        } 
    }

    public async getPartnerEntity(
        options: Partial<{ uuid: string; name: string; email:string }>,
      ): Promise<PartnerEntity> {
        const queryBuilder = this._partnerRepository.createQueryBuilder(
          'partner',
        );
    
        if (options.uuid) {
          //@todo call admin user
          queryBuilder
          .leftJoinAndSelect("partner.user", "user")
          .orWhere('partner.uuid = :uuid', {
            uuid: options.uuid,
          });
        }
    
        if (options.name) {
          queryBuilder.orWhere('partner.name = :name', {
            name: options.name,
          });
        }
        if (options.email) {
          queryBuilder.orWhere('partner.email = :email', {
            email: options.email,
          });
        }
        const result = await queryBuilder.getOne()
        return result
    }

    public async getPartners(
        pageOptionsDto: PartnersPageOptionsDto,
      ): Promise<PartnersPageDto | undefined> {
        const queryBuilder = this._partnerRepository.createQueryBuilder(
          'partner',
        );
    
        const [partners, partnersCount] = await queryBuilder
          .skip(pageOptionsDto.skip)
          .take(pageOptionsDto.take)
          .orderBy('partner.createdAt', pageOptionsDto.order)
          .getManyAndCount();
    
        const pageMetaDto = new PageMetaDto({
          pageOptionsDto,
          itemCount: partnersCount,
        });
    
        return new PartnersPageDto(partners.toDtos(), pageMetaDto);
    }

    public async createPartner(
        partnerRegisterDto : PartnerRegisterDto
    ) : Promise<PartnerEntity> {
            const partner = this._partnerRepository.create(partnerRegisterDto);
            const result = await this._partnerRepository.save(partner);
            if(result) {
              return result;
            }
    }

    public async updatePartnerData( // PATCH
      uuid : string,
      partnerUpdateDto: PartnerUpdateDto,
    ): Promise<PartnerEntity> {
      const partner = await this.getPartner({ uuid: uuid })

      if (partnerUpdateDto.email) {
        const isEmail = await this.getPartner({ email: partnerUpdateDto.email });
        if (isEmail) {
          throw new EmailAddressExistException();
        }
        // await this._partnerRepository.update(partner.id, {
        //   email: partnerUpdateDto.email,
        // });
        partner.email = partnerUpdateDto.email
      }
      if (partnerUpdateDto.name) {

        partner.name = partnerUpdateDto.name
      }
      if (partnerUpdateDto.contact) {

        partner.name = partnerUpdateDto.contact
      }
      if (partnerUpdateDto.address) {

        partner.name = partnerUpdateDto.address
      }
      const updatedData = await this._partnerRepository.save(partner)
      return updatedData;
    }

    public async deletePartner(uuid: string): Promise<void> {
      try {
        const found = await this.getPartner({ uuid: uuid });
        await this._partnerRepository.delete(found.id);   
      } catch (error) {
        throw new DeleteFailedException(error);
      }
    }
}