import os
import gradio as gr
from sympy.core.numbers import Rational
from solution import BadInput, solutions


def generate_md(args_dict, name):
    try:
        ans_latex = solutions[name](**args_dict).get_latex_ans()

    except BadInput as e:
        return f"Incorrectly entered. Please enter a valid number: {e}"

    return f"Note that $${ans_latex}$$ QED"


def float_to_fraction(x):
    x_str = "{0:.10f}".format(x).rstrip("0").rstrip(".")  # 移除小数点后的无效零

    # 检查是否为整数
    if "." not in x_str:
        return Rational(x_str), Rational(1)

    # 分割整数部分和小数部分
    integer_part, decimal_part = x_str.split(".")
    decimal_digits = len(decimal_part)

    # 构造分子和分母
    numerator = int(integer_part + decimal_part)
    denominator = 10**decimal_digits

    # 简化分数
    gcd_value = 1
    a = numerator
    b = denominator
    while b != 0:
        a, b = b, a % b
        gcd_value = a

    p = Rational(numerator // gcd_value)
    q = Rational(denominator // gcd_value)
    return p, q


def infer_pi(p, q):
    if q == 0:
        return "The denominator can not be 0 !"

    p, q = float_to_fraction(p / q)
    args_dict = {"p": p, "q": q}
    return generate_md(args_dict, "π")


def infer_e(p, q):
    if q == 0:
        return "The denominator can not be 0 !"

    p, q = float_to_fraction(p / q)
    args_dict = {"p": p, "q": q}
    return generate_md(args_dict, "e")


def infer_eq(q1, q2, u, v):
    if q2 == 0 or v == 0:
        return "The denominator can not be 0 !"

    q1, q2 = float_to_fraction(q1 / q2)
    u, v = float_to_fraction(u / v)
    args_dict = {"q1": q1, "q2": q2, "u": u, "v": v}
    return generate_md(args_dict, "e^q")


def infer_pin(n: int, p, q):
    if q == 0:
        return "The denominator can not be 0 !"

    p, q = float_to_fraction(p / q)
    args_dict = {"n": n, "p": p, "q": q}
    return generate_md(args_dict, "π^n")


if __name__ == "__main__":
    os.chdir(os.path.dirname(__file__))
    for file_name in os.listdir("solutions"):
        if not file_name.endswith(".py"):
            continue

        __import__(f"solutions.{file_name[:-3]}")

    with gr.Blocks() as demo:
        gr.Markdown("# Compare sizes by 'Note that' proof")
        with gr.Tabs():
            with gr.TabItem("π"):
                gr.Interface(
                    fn=infer_pi,
                    inputs=[
                        gr.Number(label="p", value=314),
                        gr.Number(label="q", value=100),
                    ],
                    outputs=gr.Markdown(
                        value="#### Proof result",
                        show_copy_button=True,
                        container=True,
                        min_height=122,
                    ),
                    title="Compare π and p/q",
                    allow_flagging="never",
                )

            with gr.TabItem("e"):
                gr.Interface(
                    fn=infer_e,
                    inputs=[
                        gr.Number(label="p", value=2718),
                        gr.Number(label="q", value=1000),
                    ],
                    outputs=gr.Markdown(
                        value="#### Proof result",
                        show_copy_button=True,
                        container=True,
                        min_height=122,
                    ),
                    title="Compare e and p/q",
                    allow_flagging="never",
                )

            with gr.TabItem("e^q"):
                gr.Interface(
                    fn=infer_eq,
                    inputs=[
                        gr.Number(label="p", value=3),
                        gr.Number(label="q", value=4),
                        gr.Number(label="u", value=2117),
                        gr.Number(label="v", value=1000),
                    ],
                    outputs=gr.Markdown(
                        value="#### Proof result",
                        show_copy_button=True,
                        container=True,
                        min_height=122,
                    ),
                    title="Compare e^(p/q) and u/v",
                    allow_flagging="never",
                )

            with gr.TabItem("π^n"):
                gr.Interface(
                    fn=infer_pin,
                    inputs=[
                        gr.Number(label="n", value=3, step=1),
                        gr.Number(label="p", value=31),
                        gr.Number(label="q", value=1),
                    ],
                    outputs=gr.Markdown(
                        value="#### Proof result",
                        show_copy_button=True,
                        container=True,
                        min_height=122,
                    ),
                    title="Compare π^n and p/q",
                    allow_flagging="never",
                )

    demo.launch()