import { forwardRef, HttpException, HttpStatus, Inject, Injectable } from '@nestjs/common';
import { CreateUserDto } from './dto/create-user.dto';
import { UpdateUserDto } from './dto/update-user.dto';
import { Connection, EntityNotFoundError, Repository } from 'typeorm';
import { User } from './entities/user.entity';
import { InjectRepository } from '@nestjs/typeorm';
import { randomStringGenerator } from '@nestjs/common/utils/random-string-generator.util';
import { hashPassword } from '../helper/hash_password';
import { CoaService } from 'src/transaction/coa.service';
import { balanceType, coaType } from 'src/helper/enum-list';
import { RoleService } from 'src/configurable/roles.service';
import { InputCoaDto } from 'src/transaction/dto/input-coa.dto';
import * as uuid from "uuid";

@Injectable()
export class UsersService {
  constructor(
    @InjectRepository(User)
    private usersRepository: Repository<User>,
    @Inject(forwardRef(() => CoaService))
    private coaService: CoaService,
    private roleService: RoleService,
    private connection: Connection,
  ) {}

  async create(createUserDto: CreateUserDto, currentUser: any) {
    const roles = await this.roleService.findOne(createUserDto.roleId);
    const superior = await this.findByUsername(currentUser.username);
    const salt = randomStringGenerator();
    
    let userData = new User();
    userData.id = uuid.v4();
    userData.username = createUserDto.username,
    userData.password = await hashPassword(createUserDto.password, salt),
    userData.salt = salt,
    userData.superior = superior,
    userData.roles = roles

    await this.connection.transaction(async (manager) => {
      const result = await manager.insert(User,userData);
  
      let dataCoaWallet = new InputCoaDto();
      dataCoaWallet.user = userData;
      dataCoaWallet.balanceType = balanceType.CREDIT;
      dataCoaWallet.type = coaType.WALLET;
      dataCoaWallet.coaEntityManager = manager;
  
      if(createUserDto.superior){
        let dataCoaAP = new InputCoaDto();
        dataCoaAP.user = userData;
        dataCoaAP.balanceType = balanceType.CREDIT;
        dataCoaAP.relatedUserId = superior.id;
        dataCoaAP.type = coaType.ACCOUNT_PAYABLE;
        dataCoaAP.coaEntityManager = manager;
  
        let dataCoaAR = new InputCoaDto();
        dataCoaAR.user = userData;
        dataCoaAR.balanceType = balanceType.DEBIT;
        dataCoaAR.relatedUserId = superior.id;
        dataCoaAR.type = coaType.ACCOUNT_RECEIVABLE;
        dataCoaAR.coaEntityManager = manager;
        
        await this.coaService.create(dataCoaAP);
        await this.coaService.create(dataCoaAR);
      }
  
      await this.coaService.create(dataCoaWallet);

    })

    return userData;
  }

  findAll(page:number) {
    return this.usersRepository.findAndCount({
      skip: page * 10,
      take: 10,
      order: {
        version: 'DESC',
      },
    });
  }

  findByRoles(relationId:string,page:number) {
    return this.usersRepository.findAndCount({
      skip: page * 10,
      take: 10,
      where:{
        roles:relationId
      },
      order: {
        updatedAt: 'DESC',
      },
    });
  }

  async findExist(id: string) {
    try {
     return await this.usersRepository.findOneOrFail(id);
    } catch (e) {
      if (e instanceof EntityNotFoundError) {
        throw new HttpException(
          {
            statusCode: HttpStatus.NOT_FOUND,
            error: 'Data not found',
          },
          HttpStatus.NOT_FOUND,
        );
      } else {
        throw e;
      }
    }
  }

  async findByUsername(username: string) {
    try {
     return await this.usersRepository.findOneOrFail({
       username:username
     });
    } catch (e) {
      if (e instanceof EntityNotFoundError) {
        throw new HttpException(
          {
            statusCode: HttpStatus.NOT_FOUND,
            error: 'Data not found',
          },
          HttpStatus.NOT_FOUND,
        );
      } else {
        throw e;
      }
    }
  }

  async findOne(id: string) {
    const coa = await this.coaService.findByUser(id,coaType.WALLET);
    try {
      const userData =  await this.usersRepository.findOneOrFail({ 
        where: { 
          id: id 
        },
        relations:["roles","superior"] 
      });
      return {
        ...userData,
        wallet:coa.amount,
      };
    } catch (e) {
      if (e instanceof EntityNotFoundError) {
        throw new HttpException(
          {
            statusCode: HttpStatus.NOT_FOUND,
            error: 'Data not found',
          },
          HttpStatus.NOT_FOUND,
        );
      } else {
        throw e;
      }
    }
  }

  async update(id: string, updateUserDto: UpdateUserDto) {
    try {
      await this.usersRepository.findOneOrFail(id);
    } catch (e) {
      if (e instanceof EntityNotFoundError) {
        throw new HttpException(
          {
            statusCode: HttpStatus.NOT_FOUND,
            error: 'Data not found',
          },
          HttpStatus.NOT_FOUND,
        );
      } else {
        throw e;
      }
    }

    // const result = await this.usersRepository.update(id, updateUserDto);

    return this.usersRepository.findOneOrFail(id);
  }

  async remove(id: string) {
    try {
      await this.usersRepository.findOneOrFail(id);
    } catch (e) {
      if (e instanceof EntityNotFoundError) {
        throw new HttpException(
          {
            statusCode: HttpStatus.NOT_FOUND,
            error: 'Data not found',
          },
          HttpStatus.NOT_FOUND,
        );
      } else {
        throw e;
      }
    }

    await this.usersRepository.delete(id);
  }

  async findOneByUsername(username: string) {
    return this.usersRepository.findOneOrFail({
      where: {
        username,
      },
    });
  }
}