import { Logger } from '../common'

import { BigNumberish, tenExponentiate } from './bignumber'
import { Rounding } from './constant'
import { Currency, currencyEquals } from './currency'
import { Fraction } from './fraction'

const logger = Logger.from('entity/price')

export class Price extends Fraction {
  public readonly baseCurrency: Currency // input i.e. denominator
  public readonly quoteCurrency: Currency // output i.e. numerator
  // used to adjust the raw fraction w/r/t the decimals of the {base,quote}Token
  public readonly scalar: Fraction

  // denominator and numerator _must_ be raw, i.e. in the native representation
  public constructor(
    baseCurrency: Currency,
    denominator: BigNumberish,
    quoteCurrency: Currency,
    numerator: BigNumberish,
  ) {
    super(numerator, denominator)

    this.baseCurrency = baseCurrency
    this.quoteCurrency = quoteCurrency
    this.scalar = new Fraction(tenExponentiate(baseCurrency.decimals), tenExponentiate(quoteCurrency.decimals))
  }

  public get raw(): Fraction {
    return new Fraction(this.numerator, this.denominator)
  }

  public get adjusted(): Fraction {
    return super.mul(this.scalar)
  }

  public invert(): Price {
    return new Price(this.quoteCurrency, this.numerator, this.baseCurrency, this.denominator)
  }

  public mul(other: Price): Price {
    logger.assert(currencyEquals(this.quoteCurrency, other.baseCurrency), 'mul currency not equals')

    const fraction = super.mul(other)
    return new Price(this.baseCurrency, fraction.denominator, other.quoteCurrency, fraction.numerator)
  }

  public toSignificant(significantDigits = this.quoteCurrency.decimals, format?: object, rounding?: Rounding): string {
    return this.adjusted.toSignificant(significantDigits, format, rounding)
  }

  public toFixed(decimalPlaces = this.quoteCurrency.decimals, format?: object, rounding?: Rounding): string {
    return this.adjusted.toFixed(decimalPlaces, format, rounding)
  }
}