export abstract class StaticBase {
  ID: number;
  ENUM_ID: string;
}

import { ClsModule } from 'nestjs-cls';

@Module({
  imports: [
    ClsModule.forRoot({ 
      global: true, 
      middleware: { mount: true } 
    }),
  ],
})
export class AppModule {}

@Catch()
export class AllExceptionFilter implements ExceptionFilter {
  constructor(private readonly httpAdapterHost: HttpAdapterHost) {}

  catch(exception: any, host: ArgumentsHost): void {
    const { httpAdapter } = this.httpAdapterHost;

    const ctx = host.switchToHttp();

    const isServerErrorException =
      exception.response && isNumber(exception.response);

    const httpStatusCode = isServerErrorException
      ? HttpStatus.OK
      : (exception?.response?.statusCode ?? HttpStatus.INTERNAL_SERVER_ERROR);

    const errorCode = isServerErrorException
      ? exception.response
      : INTERNAL_ERROR_CODE.UNKNOWN_FATAL_ERROR;

    const message = exception?.message;

    const body = isServerErrorException
      ? ResponseEntity.error(errorCode, message)
      : {
          code: errorCode,
          timestamp: ContextProvider.getNow()?.toISOString() ?? new Date(),
          path: httpAdapter.getRequestUrl(ctx.getRequest()),
          error: exception.name,
          message: message,
        };

    httpAdapter.reply(ctx.getResponse(), body, httpStatusCode);

    const requestContext = ctx.getRequest();
    // logging
    const request = {
      url: requestContext.url,
      method: requestContext.method,
      headers: requestContext.headers,
      body: requestContext.body,
    };

    const errorMessage = {
      request: request,
      session: undefined,
      exception: isServerErrorException
        ? exception
        : // unknown error
          {
            ...body,
            ...(exception?.stack ? { stack: exception.stack } : {}),
          },
    };

    Logger.error(errorMessage);
  }
}

type DelegateFunctionReturn = CurrencyDto | CharacterDto;

type ConsumeDelegate = Partial<
  Record<GoodsType, (materials: Cost[]) => Promise<DelegateFunctionReturn[]>>
>;

@Injectable()
export class ConsumptionProvider {
  private readonly consumeDelegate: ConsumeDelegate = {
    [GOODS_TYPE.CURRENCY]: (
      materials: Cost[],
    ): Promise<DelegateFunctionReturn[]> => this._consumeCurrency(materials),

    [GOODS_TYPE.CHARACTER]: (
      materials: Cost[],
    ): Promise<DelegateFunctionReturn[]> => this._consumeCharacter(materials),
  };

  constructor(
    private readonly userDetailProvider: UserDetailProvider,
    private readonly dataCurrencyRepository: DataCurrencyRepository,
    private readonly characterProvider: CharacterProvider,
    private readonly dataCharacterProvider: DataCharacterProvider,
  ) {}

  /**
   * 소모
   */
  async consume(materials: Cost[]): Promise<GoodsOutDto> {
    const materialMap = new Map<GoodsType, Cost[]>();

    for (const material of materials) {
      const goodsType = material.goodsType;
      materialMap.has(goodsType)
        ? materialMap.get(goodsType).push(material)
        : materialMap.set(goodsType, [material]);
    }

    const results = [];
    for (const [goodsType, materials] of [...materialMap]) {
      const func = this.consumeDelegate[goodsType];
      if (!func) {
        throw new ServerErrorException(INTERNAL_ERROR_CODE.DATA_INVALID, [
          `${goodsType}타입은 소모 할수 없는 재화 입니다.`,
        ]);
      }
      results.push(await func(materials));
    }

    return await this._distinctGoods(flatten(results));
  }

  /**
   * 통화 소모 by enumId
   */
  private async _consumeCurrency(materials: Cost[]): Promise<CurrencyDto[]> {
    const userDetail = await this.userDetailProvider.getUserDetail();

    // 각 material 의 재화는 이전에 통합을 통해 독립적인 dataId(currency Type)으로 들어온다.
    for (const material of materials) {
      const dataCurrency = this.dataCurrencyRepository.findById(
        material.dataId,
      );

      if (!dataCurrency) {
        throw new ServerErrorException(INTERNAL_ERROR_CODE.DATA_INVALID, [
          `${material.dataId}는 재화 데이터에 존재하지 않은 아이디 입니다.`,
        ]);
      }

      const currencyProp = CURRENCY_PROPS[dataCurrency.CURRENCY_TYPE];
      if (!currencyProp) {
        throw new ServerErrorException(
          INTERNAL_ERROR_CODE.USER_DETAIL_UNKNOWN_CURRENCY_TYPE,
        );
      }

      // 통화 수량 확인
      if (userDetail.currency[currencyProp] < material.quantity) {
        const errorCode = `USER_DETAIL_CURRENCY_${currencyProp.toUpperCase()}_NOT_ENOUGH`;
        throw new ServerErrorException(INTERNAL_ERROR_CODE[errorCode]);
      }

      userDetail.currency[currencyProp] -= material.quantity;
    }

    await this.userDetailProvider.updateUserDetail(userDetail);

    return [CurrencyDto.fromEntity(userDetail.currency)];
  }

  /**
   * 통화 소모 by enumId
   */
  private async _consumeCharacter(materials: Cost[]): Promise<CharacterDto[]> {
    const dataIds = materials.map((it) => it.dataId);
    const characters =
      await this.characterProvider.getCharactersByDataCharacterIds(dataIds);

    const characterByDataCharacterId = Object.fromEntries(
      characters.map((it) => [it.dataCharacterId, it]),
    );

    for (const material of materials) {
      const { dataId, quantity } = material;
      const character = characterByDataCharacterId[dataId];

      const dataCharacter = this.dataCharacterProvider.getDataCharacter(dataId);

      if (!dataCharacter) {
        throw new ServerErrorException(INTERNAL_ERROR_CODE.DATA_INVALID, [
          `${dataId}는 캐릭터 데이터에 존재하지 않은 아이디 입니다.`,
        ]);
      }

      if (!character) {
        throw new ServerErrorException(
          INTERNAL_ERROR_CODE.CHARACTER_NOT_FOUND,
          [dataId],
        );
      }

      // 통화 수량 확인
      if (character.count < quantity) {
        throw new ServerErrorException(
          INTERNAL_ERROR_CODE.CHARACTER_NOT_ENOUGH,
          [dataId],
        );
      }

      character.count -= quantity;
    }

    await this.characterProvider.saveCharacters(characters);

    return CharacterDto.fromEntities(characters);
  }

  /**
   * 중복 재화 처리
   */
  private async _distinctGoods(
    results: DelegateFunctionReturn[],
  ): Promise<GoodsOutDto> {
    // 통화 중복 처리
    const currencyDto = await this._distinctCurrency(
      results.filter((it) => it instanceof CurrencyDto) as CurrencyDto[],
    );

    const goodsDto = GoodsOutDto.of({
      currency: currencyDto,
    });

    return ObjectUtil.removeEmptyProperties(goodsDto);
  }

  /**
   * 중복 통화 처리
   */
  private async _distinctCurrency(
    currenciesDto: CurrencyDto[],
  ): Promise<CurrencyDto> {
    if (currenciesDto.isEmpty()) {
      return null;
    }

    if (currenciesDto.length === 1) {
      return currenciesDto[0];
    }

    const userDetail = await this.userDetailProvider.getUserDetail();

    return CurrencyDto.fromEntity(userDetail.currency);
  }
}