import {
  forwardRef,
  HttpException,
  HttpStatus,
  Inject,
  Injectable,
} from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Connection, EntityNotFoundError, Repository } from 'typeorm';
import { Supplier } from './entities/supplier.entity';
import { InputCoaDto } from '../transaction/dto/input-coa.dto';
import { balanceType, coaType } from '../helper/enum-list';
import { CreateSupplierDto } from './dto/create-supplier.dto';
import { CoaService } from '../transaction/coa.service';
import * as uuid from 'uuid';

@Injectable()
export class SupplierService {
  constructor(
    @InjectRepository(Supplier)
    private supplierRepository: Repository<Supplier>,
    @Inject(
      forwardRef(() => {
        return CoaService;
      }),
    )
    private coaService: CoaService,
    private connection: Connection,
  ) {}

  async create(createSupplierDto: CreateSupplierDto) {
    const check = await this.supplierRepository.findOne({
      code: createSupplierDto.code,
    });

    if (check) {
      throw new HttpException(
        {
          statusCode: HttpStatus.NOT_ACCEPTABLE,
          error: 'Supplier Already Exist',
        },
        HttpStatus.NOT_FOUND,
      );
    }

    const supplierData = new Supplier();
    supplierData.id = uuid.v4();
    supplierData.name = createSupplierDto.name;
    supplierData.code = createSupplierDto.code;
    supplierData.status = true;

    await this.connection.transaction(async (manager) => {
      const result = await manager.insert(Supplier, supplierData);

      const dataCoaInventory = new InputCoaDto();
      dataCoaInventory.supplier = supplierData;
      dataCoaInventory.balanceType = balanceType.DEBIT;
      dataCoaInventory.type = coaType.INVENTORY;
      dataCoaInventory.coaEntityManager = manager;
      await this.coaService.create(dataCoaInventory);

      const dataCoaCostOfSales = new InputCoaDto();
      dataCoaCostOfSales.supplier = supplierData;
      dataCoaCostOfSales.balanceType = balanceType.DEBIT;
      dataCoaCostOfSales.type = coaType.COST_OF_SALES;
      dataCoaCostOfSales.coaEntityManager = manager;
      await this.coaService.create(dataCoaCostOfSales);

      const dataCoaBudget = new InputCoaDto();
      dataCoaBudget.supplier = supplierData;
      dataCoaBudget.balanceType = balanceType.DEBIT;
      dataCoaBudget.type = coaType.BUDGET;
      dataCoaBudget.coaEntityManager = manager;
      await this.coaService.create(dataCoaBudget);

      const dataCoaContraBudget = new InputCoaDto();
      dataCoaContraBudget.supplier = supplierData;
      dataCoaContraBudget.balanceType = balanceType.CREDIT;
      dataCoaContraBudget.type = coaType.CONTRA_BUDGET;
      dataCoaContraBudget.coaEntityManager = manager;
      await this.coaService.create(dataCoaContraBudget);
    });

    return supplierData;
  }

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

  async findOne(id: string) {
    try {
      return await this.supplierRepository.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;
      }
    }
  }
}