import time

from decimal import Decimal, getcontext
from difflib import SequenceMatcher
from pint import UnitRegistry
from rich.console import Console
from rich.table import Table
from rich.style import Style


ureg = UnitRegistry()
Quantity = ureg.Quantity


class FormatedDecimal(Decimal):
    """Make sure we display the number in the fully expanded (not scientific) notation."""

    def __str__(self):
        return f"{self:.{abs(self.as_tuple().exponent)}f}"


# Example values
str_a = "2.5489120456102"
str_b = "83.21598756102002"
str_c = "0.0002"
str_d = "0.00000000000000000000000000000000965112"
str_e = "745205937266232843946623988365475210078512674585246585"
str_f = "63.1111111111111111111111111111111111101"
str_g = "4522010410540451204102045263884101623.174125843864637484832326463289748"

# Float version of examples
float_a = float(str_a)
float_b = float(str_b)
float_c = float(str_c)
float_d = float(str_d)
float_e = float(str_e)
float_f = float(str_f)
float_g = float(str_g)

# Decimal version of examples converted to Quantities
quantity_a = Quantity(Decimal(str_a), "ft")
quantity_b = Quantity(Decimal(str_b), "ft")
quantity_c = Quantity(Decimal(str_c), "ft")
quantity_d = Quantity(Decimal(str_d), "ft")
quantity_e = Quantity(Decimal(str_e), "ft")
quantity_f = Quantity(Decimal(str_f), "ft")
quantity_g = Quantity(Decimal(str_g), "ft")

# Iterables used in conversions
precision_levels = [4, 5, 6, 8, 10, 15, 20, 25, 50, 75, 100, 125, 150, 200, 250]
units = [
    ("ft", "ft", "ft"),
    ("attometer", "exameter", "ft"),
    ("exameter", "attometer", "ft"),
]
operations = [
    {"function": add, "representation": "+"},
    {"function": subtract, "representation": "-"},
    {"function": multiply, "representation": "*"},
    {"function": divide, "representation": "/"},
]
all_quantities = [quantity_a, quantity_b, quantity_c, quantity_d, quantity_e, quantity_f, quantity_g]

combinations = [
    {
        "strings": [str_a, str_b, str_c],
        "floats": [float_a, float_b, float_c],
        "quantities": [quantity_a, quantity_b, quantity_c],
    },
    {
        "strings": [str_b, str_c, str_d],
        "floats": [float_b, float_c, float_d],
        "quantities": [quantity_b, quantity_c, quantity_d],
    },
    {
        "strings": [str_c, str_d, str_e],
        "floats": [float_c, float_d, float_e],
        "quantities": [quantity_c, quantity_d, quantity_e],
    },
    {
        "strings": [str_d, str_e, str_f],
        "floats": [float_d, float_e, float_f],
        "quantities": [quantity_d, quantity_e, quantity_f],
    },
    {
        "strings": [str_e, str_f, str_g],
        "floats": [float_e, float_f, float_g],
        "quantities": [quantity_e, quantity_f, quantity_g],
    },
    {
        "strings": [str_f, str_g, str_a],
        "floats": [float_f, float_g, float_a],
        "quantities": [quantity_f, quantity_g, quantity_a],
    },
    {
        "strings": [str_g, str_a, str_b],
        "floats": [float_g, float_a, float_b],
        "quantities": [quantity_g, quantity_a, quantity_b],
    },
]

start = time.perf_counter()


def add(x, y, z, precision_level=1):
    """Performs the addition operation with the three values, returning the table with the newly added row."""
    getcontext().prec = precision_level
    operation_result = x + y + z
    return operation_result


def subtract(x, y, z, precision_level=1):
    """Performs the subtraction operation with the three values, returning the table with the newly added row."""
    getcontext().prec = precision_level
    operation_result = x - y - z
    return operation_result


def multiply(x, y, z, precision_level=1):
    """Performs the multiplication operation with the three values, returning the table with the newly added row."""
    getcontext().prec = precision_level
    operation_result = x * y * z
    return operation_result


def divide(x, y, z, precision_level=1):
    """Performs the division operation with the three values, returning the table with the newly added row."""
    getcontext().prec = precision_level
    operation_result = x / y / z
    return operation_result


def print_quantities_at_each_precision():
    """Prints the quantities at each precision level."""
    console = Console(record=True)
    for quantity in all_quantities:
        print("\n\n")

        table = Table(title="Checking precision of original values")
        columns = ["Prec", "Value 1"]
        for column in columns:
            table.add_column(column)

        # Temporarily set to max precision to get the length of the fully expanded number
        getcontext().prec = precision_levels[-1]
        max_precision_value = str(FormatedDecimal(quantity.magnitude.normalize())).rstrip("0").rstrip(".")

        for precision_level in precision_levels:
            getcontext().prec = precision_level
            formatted_value = str(FormatedDecimal(quantity.magnitude.normalize())).rstrip("0").rstrip(".")
            table.add_row(
                str(precision_level),
                formatted_value,
                style=Style(color="green") if formatted_value == max_precision_value else Style(color="red"),
            )

        console.print(table)
    # print(console.export_html())


def print_examples_with_various_operations():
    """Prints various combinations or the example values using different operations and precision levels."""
    console = Console(record=True)
    for operation in operations:
        for combination in combinations:

            print("\n\n")
            table = Table(
                title=(
                    f"{operation['function'].__name__}: {combination['strings'][0]} {operation['representation']} "
                    f"{combination['strings'][1]} {operation['representation']} {combination['strings'][2]}"
                )
            )
            columns = ["Type", "Prec", "Result"]
            for column in columns:
                table.add_column(column)

            # Get float value
            formatted_float_value = str(
                FormatedDecimal(operation["function"](*combination["floats"], precision_level=1))
            )
            table.add_row("float", "N/A", formatted_float_value, style=Style(color="orange3"))

            # Get value at highest precision
            max_precision_value = operation["function"](
                *combination["quantities"], precision_level=precision_levels[-1]
            )
            formatted_max_precision_value = (
                str(FormatedDecimal(max_precision_value.magnitude.normalize())).rstrip("0").rstrip(".")
            )

            # Compare float with max value, and add a row showing where they differ
            s = SequenceMatcher(None, formatted_float_value, formatted_max_precision_value)
            matching_blocks = s.get_matching_blocks()
            if len(matching_blocks) > 0:
                match_length = matching_blocks[0].size
                table.add_row(
                    "(match)",
                    "N/A",
                    f"{'-' * (match_length)}{'x' * (len(formatted_float_value) - match_length)}",
                    style=Style(color="orange3"),
                )

            for precision_level in precision_levels:
                quantity_value = operation["function"](*combination["quantities"], precision_level)
                formatted_quantity_value = (
                    str(FormatedDecimal(quantity_value.magnitude.normalize())).rstrip("0").rstrip(".")
                )
                table.add_row(
                    "Quantity",
                    str(precision_level),
                    formatted_quantity_value,
                    style=(
                        Style(color="green")
                        if formatted_quantity_value == formatted_max_precision_value
                        else Style(color="red")
                    ),
                )

            console.print(table)
    # print(console.export_html())


print_quantities_at_each_precision()
print("\n\n")
print_examples_with_various_operations()

end = time.perf_counter()
print(f"Time taken: {end - start:.2f} seconds")