import math


class Calculator:
    def get_price(self, data, level):
        return self.calculate_formula(data.priceFormula, level, data.priceBasic, data.priceFormulaK) if level else 0

    def get_profit(self, data, level):
        return (
            self.calculate_formula(data.profitFormula, level, data.profitBasic, data.priceFormulaK, data)
            if level
            else 0
        )

    def calculate_formula(self, formula, level, base_value, formula_coefficient, data=None):
        result = base_value
        if formula == "fnCompound":
            result = self.fn_compound(level, base_value, formula_coefficient)
        elif formula == "fnLogarithmic":
            result = self.fn_logarithmic(level, base_value)
        elif formula == "fnLinear":
            result = self.fn_linear(level, base_value)
        elif formula == "fnQuadratic":
            result = self.fn_quadratic(level, base_value)
        elif formula == "fnCubic":
            result = self.fn_cubic(level, base_value)
        elif formula == "fnExponential":
            result = self.fn_exponential(level, base_value, formula_coefficient)
        elif formula == "fnPayback":
            result = self.fn_payback(level, data)

        return self.smart_round(result)

    def smart_round(self, value):
        def round_to(value, factor=100):
            return round(value / factor) * factor

        if value < 50:
            return round(value)
        elif value < 100:
            return round_to(value, 5)
        elif value < 500:
            return round_to(value, 25)
        elif value < 1000:
            return round_to(value, 50)
        elif value < 5000:
            return round_to(value, 100)
        elif value < 10000:
            return round_to(value, 200)
        elif value < 100000:
            return round_to(value, 500)
        elif value < 500000:
            return round_to(value, 1000)
        elif value < 1000000:
            return round_to(value, 5000)
        elif value < 50000000:
            return round_to(value, 10000)
        elif value < 100000000:
            return round_to(value, 50000)
        else:
            return round_to(value, 100000)

    def fn_linear(self, level, base_value):
        return base_value * level

    def fn_quadratic(self, level, base_value):
        return base_value * level * level

    def fn_cubic(self, level, base_value):
        return base_value * level * level * level

    def fn_exponential(self, level, base_value, coefficient):
        return base_value * math.pow(coefficient / 10, level)

    def fn_logarithmic(self, level, base_value):
        return base_value * math.log2(level + 1)

    def fn_compound(self, level, base_value, coefficient):
        compound_rate = coefficient / 100
        return base_value * math.pow(1 + compound_rate, level - 1)

    def fn_payback(self, level, data):
        accumulated = [0]
        for current_level in range(1, level + 1):
            previous_accumulated = accumulated[current_level - 1]
            current_price = self.get_price(data, current_level)
            current_profit = data.profitBasic + data.profitFormulaK * (current_level - 1)
            smart_rounded_value = self.smart_round(previous_accumulated + current_price / current_profit)
            accumulated.append(smart_rounded_value)
        return accumulated[level]