app.py

import gradio as gr
import numpy as np
from typing import Dict, Any, Tuple
import traceback

from calculator.core import (
    InfinitePrecisionCalculator, 
    ScientificCalculator, 
    ProgrammingCalculator,
    ComplexNumber
)
from engineering.impedance import (
    PowerSystemImpedanceCalculator,
    ConductorParams,
    Coordinate,
    create_test_data
)

class CalculatorApp:
    """Main calculator application with multiple modes."""
    
    def __init__(self):
        self.standard_calc = InfinitePrecisionCalculator()
        self.scientific_calc = ScientificCalculator()
        self.programming_calc = ProgrammingCalculator()
        self.impedance_calc = PowerSystemImpedanceCalculator()
        self.current_display = "0"
        self.current_operation = None
        self.operand = None
        self.chat_history = []
    
    def standard_button_click(self, button: str, display: str) -> str:
        """Handle standard calculator button clicks."""
        try:
            if button == "C":
                return "0"
            elif button == "CE":
                return "0"
            elif button == "±":
                if display != "0":
                    return str(-float(display))
                return display
            elif button == "=":
                if self.current_operation and self.operand is not None:
                    try:
                        if self.current_operation == "+":
                            result = self.standard_calc.add(self.operand, float(display))
                        elif self.current_operation == "-":
                            result = self.standard_calc.subtract(self.operand, float(display))
                        elif self.current_operation == "×":
                            result = self.standard_calc.multiply(self.operand, float(display))
                        elif self.current_operation == "÷":
                            result = self.standard_calc.divide(self.operand, float(display))
                        self.current_operation = None
                        self.operand = None
                        return str(result)
                    except Exception as e:
                        return f"Error: {str(e)}"
            elif button in ["+", "-", "×", "÷"]:
                self.current_operation = button
                self.operand = float(display)
                return "0"
            elif button == ".":
                if "." not in display:
                    return display + "."
                return display
            else:  # Number button
                if display == "0":
                    return button
                else:
                    return display + button
        except Exception as e:
            return f"Error: {str(e)}"
        
        return display
    
    def scientific_calculate(self, function: str, x: str, y: str = None) -> str:
        """Handle scientific calculator functions."""
        try:
            if not x.strip():
                return "Error: Please enter a value"
            
            x_val = float(x)
            
            if function == "sin":
                result = self.scientific_calc.sin(x_val)
            elif function == "cos":
                result = self.scientific_calc.cos(x_val)
            elif function == "tan":
                result = self.scientific_calc.tan(x_val)
            elif function == "asin":
                result = self.scientific_calc.asin(x_val)
            elif function == "acos":
                result = self.scientific_calc.acos(x_val)
            elif function == "atan":
                result = self.scientific_calc.atan(x_val)
            elif function == "csc":
                result = self.scientific_calc.csc(x_val)
            elif function == "sec":
                result = self.scientific_calc.sec(x_val)
            elif function == "cot":
                result = self.scientific_calc.cot(x_val)
            elif function == "log":
                if y and y.strip():
                    result = self.scientific_calc.log(x_val, float(y))
                else:
                    result = self.scientific_calc.log(x_val)
            elif function == "ln":
                result = self.scientific_calc.log(x_val)
            elif function == "sqrt":
                result = self.scientific_calc.square_root(x_val)
            elif function == "factorial":
                result = self.scientific_calc.factorial(int(x_val))
            elif function == "power":
                if y and y.strip():
                    result = self.scientific_calc.power(x_val, float(y))
                else:
                    return "Error: Power function requires two values"
            else:
                return f"Error: Unknown function {function}"
                
            return str(result)
            
        except Exception as e:
            return f"Error: {str(e)}"
    
    def programming_calculate(self, operation: str, input_val: str, base_from: str = "decimal", base_to: str = "decimal") -> str:
        """Handle programming calculator operations."""
        try:
            if operation == "convert":
                if base_from == "decimal":
                    num = int(input_val)
                    if base_to == "binary":
                        return self.programming_calc.to_binary(num)
                    elif base_to == "hexadecimal":
                        return self.programming_calc.to_hexadecimal(num)
                    elif base_to == "octal":
                        return self.programming_calc.to_octal(num)
                elif base_from == "binary":
                    num = self.programming_calc.from_binary(input_val)
                    if base_to == "decimal":
                        return str(num)
                    elif base_to == "hexadecimal":
                        return self.programming_calc.to_hexadecimal(num)
                    elif base_to == "octal":
                        return self.programming_calc.to_octal(num)
                elif base_from == "hexadecimal":
                    num = self.programming_calc.from_hexadecimal(input_val)
                    if base_to == "decimal":
                        return str(num)
                    elif base_to == "binary":
                        return self.programming_calc.to_binary(num)
                    elif base_to == "octal":
                        return self.programming_calc.to_octal(num)
                elif base_from == "octal":
                    num = self.programming_calc.from_octal(input_val)
                    if base_to == "decimal":
                        return str(num)
                    elif base_to == "binary":
                        return self.programming_calc.to_binary(num)
                    elif base_to == "hexadecimal":
                        return self.programming_calc.to_hexadecimal(num)
                        
            return "Conversion completed"
            
        except Exception as e:
            return f"Error: {str(e)}"
    
    def engineering_calculate(self, function: str, **kwargs) -> str:
        """Handle engineering calculations."""
        try:
            if function == "3ph_impedance":
                return self.calculate_3ph_impedance(**kwargs)
            else:
                return f"Error: Unknown engineering function {function}"
        except Exception as e:
            return f"Error: {str(e)}\n{traceback.format_exc()}"
    
    def calculate_3ph_impedance(self, coord_a_x: float, coord_a_y: float,
                               coord_b_x: float, coord_b_y: float,
                               coord_c_x: float, coord_c_y: float,
                               coord_n_x: float, coord_n_y: float,
                               coord_pe_x: float, coord_pe_y: float,
                               resist_a: float, gmr_a: float,
                               resist_b: float, gmr_b: float,
                               resist_c: float, gmr_c: float,
                               resist_n: float, gmr_n: float,
                               resist_pe: float, gmr_pe: float) -> str:
        """Calculate 3-phase impedance from input parameters."""
        
        # Create coordinates
        coordinates = {
            'a': Coordinate(x=coord_a_x, y=coord_a_y),
            'b': Coordinate(x=coord_b_x, y=coord_b_y),
            'c': Coordinate(x=coord_c_x, y=coord_c_y),
            'n': Coordinate(x=coord_n_x, y=coord_n_y),
            'pe': Coordinate(x=coord_pe_x, y=coord_pe_y)
        }
        
        # Create conductor parameters
        conductor_params = {
            'a': ConductorParams(resistance=resist_a, gmr=gmr_a),
            'b': ConductorParams(resistance=resist_b, gmr=gmr_b),
            'c': ConductorParams(resistance=resist_c, gmr=gmr_c),
            'n': ConductorParams(resistance=resist_n, gmr=gmr_n),
            'pe': ConductorParams(resistance=resist_pe, gmr=gmr_pe)
        }
        
        # Calculate impedance
        primitive_matrix, reduced_matrix, distances = self.impedance_calc.calculate_impedance_from_coordinates(
            coordinates, conductor_params
        )
        
        # Format results
        return self.impedance_calc.format_results_for_display(
            primitive_matrix, reduced_matrix, distances
        )
    
    def load_test_data(self) -> Tuple[float, ...]:
        """Load test data for 3-phase impedance calculation."""
        conductor_params, coordinates = create_test_data()
        
        return (
            # Coordinates
            coordinates['a'].x, coordinates['a'].y,
            coordinates['b'].x, coordinates['b'].y,
            coordinates['c'].x, coordinates['c'].y,
            coordinates['n'].x, coordinates['n'].y,
            coordinates['pe'].x, coordinates['pe'].y,
            # Conductor parameters
            conductor_params['a'].resistance, conductor_params['a'].gmr,
            conductor_params['b'].resistance, conductor_params['b'].gmr,
            conductor_params['c'].resistance, conductor_params['c'].gmr,
            conductor_params['n'].resistance, conductor_params['n'].gmr,
            conductor_params['pe'].resistance, conductor_params['pe'].gmr
        )
    
    def get_history(self) -> str:
        """Get calculation history."""
        history = self.standard_calc.get_history()
        if not history:
            return "No calculations yet"
        return "\n".join(history[-10:])  # Show last 10 calculations
    
    def clear_history(self) -> str:
        """Clear calculation history."""
        self.standard_calc.clear_history()
        self.scientific_calc.clear_history()
        self.programming_calc.clear_history()
        return "History cleared"
    
    def chat_with_ai(self, message: str, history: list) -> Tuple[str, list]:
        """Simple AI chat interface (placeholder)."""
        # This is a placeholder for AI integration
        response = f"I received your message: '{message}'. This is a placeholder for AI chat functionality. In a real implementation, this would connect to an AI service to help with calculations and mathematical questions."
        
        history.append([message, response])
        return "", history

def create_interface():
    """Create the Gradio interface."""
    app = CalculatorApp()
    
    with gr.Blocks(title="Engineering Calculator", theme=gr.themes.Soft()) as interface:
        gr.Markdown("# 🧮 Engineering Calculator")
        gr.Markdown("Multi-mode calculator with standard, scientific, engineering, and programming capabilities")
        
        with gr.Tabs():
            # Standard Calculator Tab
            with gr.Tab("Standard"):
                with gr.Row():
                    with gr.Column(scale=2):
                        display = gr.Textbox(value="0", label="Display", interactive=False, text_align="right")
                        
                        with gr.Row():
                            gr.Button("C", size="sm").click(lambda: app.standard_button_click("C", ""), outputs=display)
                            gr.Button("CE", size="sm").click(lambda: app.standard_button_click("CE", ""), outputs=display)
                            gr.Button("±", size="sm").click(lambda x: app.standard_button_click("±", x), inputs=display, outputs=display)
                            gr.Button("÷", size="sm").click(lambda x: app.standard_button_click("÷", x), inputs=display, outputs=display)
                        
                        with gr.Row():
                            gr.Button("7", size="sm").click(lambda x: app.standard_button_click("7", x), inputs=display, outputs=display)
                            gr.Button("8", size="sm").click(lambda x: app.standard_button_click("8", x), inputs=display, outputs=display)
                            gr.Button("9", size="sm").click(lambda x: app.standard_button_click("9", x), inputs=display, outputs=display)
                            gr.Button("×", size="sm").click(lambda x: app.standard_button_click("×", x), inputs=display, outputs=display)
                        
                        with gr.Row():
                            gr.Button("4", size="sm").click(lambda x: app.standard_button_click("4", x), inputs=display, outputs=display)
                            gr.Button("5", size="sm").click(lambda x: app.standard_button_click("5", x), inputs=display, outputs=display)
                            gr.Button("6", size="sm").click(lambda x: app.standard_button_click("6", x), inputs=display, outputs=display)
                            gr.Button("-", size="sm").click(lambda x: app.standard_button_click("-", x), inputs=display, outputs=display)
                        
                        with gr.Row():
                            gr.Button("1", size="sm").click(lambda x: app.standard_button_click("1", x), inputs=display, outputs=display)
                            gr.Button("2", size="sm").click(lambda x: app.standard_button_click("2", x), inputs=display, outputs=display)
                            gr.Button("3", size="sm").click(lambda x: app.standard_button_click("3", x), inputs=display, outputs=display)
                            gr.Button("+", size="sm").click(lambda x: app.standard_button_click("+", x), inputs=display, outputs=display)
                        
                        with gr.Row():
                            gr.Button("0", size="sm").click(lambda x: app.standard_button_click("0", x), inputs=display, outputs=display)
                            gr.Button(".", size="sm").click(lambda x: app.standard_button_click(".", x), inputs=display, outputs=display)
                            gr.Button("=", size="sm").click(lambda x: app.standard_button_click("=", x), inputs=display, outputs=display)
                    
                    with gr.Column(scale=1):
                        gr.Markdown("### Memory & History")
                        with gr.Row():
                            gr.Button("MS").click(lambda x: app.standard_calc.memory_store(x), inputs=display)
                            gr.Button("MR").click(lambda: str(app.standard_calc.memory_recall()), outputs=display)
                            gr.Button("MC").click(lambda: app.standard_calc.memory_clear())
                        
                        history_display = gr.Textbox(label="History", lines=10, interactive=False)
                        gr.Button("Show History").click(app.get_history, outputs=history_display)
                        gr.Button("Clear History").click(app.clear_history, outputs=history_display)
            
            # Scientific Calculator Tab
            with gr.Tab("Scientific"):
                with gr.Row():
                    with gr.Column():
                        angle_mode = gr.Radio(["degrees", "radians"], value="degrees", label="Angle Mode")
                        x_input = gr.Number(label="X Value", value=0)
                        y_input = gr.Number(label="Y Value (for functions requiring 2 inputs)", value=0)
                        
                        function_dropdown = gr.Dropdown([
                            "sin", "cos", "tan", "asin", "acos", "atan",
                            "csc", "sec", "cot", "log", "ln", "sqrt", "factorial", "power"
                        ], label="Function", value="sin")
                        
                        calculate_btn = gr.Button("Calculate", variant="primary")
                        result_display = gr.Textbox(label="Result", interactive=False)
                        
                        def scientific_wrapper(func, x, y, mode):
                            app.scientific_calc.set_angle_mode('deg' if mode == 'degrees' else 'rad')
                            return app.scientific_calculate(func, str(x), str(y) if y != 0 else None)
                        
                        calculate_btn.click(
                            scientific_wrapper,
                            inputs=[function_dropdown, x_input, y_input, angle_mode],
                            outputs=result_display
                        )
                    
                    with gr.Column():
                        gr.Markdown("### Scientific Functions Reference")
                        gr.Markdown("""
                        **Trigonometric Functions:**
                        - sin, cos, tan: Basic trigonometric functions
                        - asin, acos, atan: Inverse trigonometric functions
                        - csc, sec, cot: Reciprocal trigonometric functions
                        
                        **Other Functions:**
                        - log: Logarithm (base 10 or custom base if Y value provided)
                        - ln: Natural logarithm (base e)
                        - sqrt: Square root
                        - factorial: Factorial (integers only)
                        - power: X raised to the power of Y
                        """)
            
            # Programming Calculator Tab
            with gr.Tab("Programming"):
                with gr.Row():
                    with gr.Column():
                        gr.Markdown("### Base Conversion")
                        input_value = gr.Textbox(label="Input Value", placeholder="Enter number to convert")
                        base_from = gr.Dropdown(["decimal", "binary", "hexadecimal", "octal"], 
                                              label="From Base", value="decimal")
                        base_to = gr.Dropdown(["decimal", "binary", "hexadecimal", "octal"], 
                                            label="To Base", value="binary")
                        
                        convert_btn = gr.Button("Convert", variant="primary")
                        conversion_result = gr.Textbox(label="Result", interactive=False)
                        
                        convert_btn.click(
                            lambda val, from_base, to_base: app.programming_calculate("convert", val, from_base, to_base),
                            inputs=[input_value, base_from, base_to],
                            outputs=conversion_result
                        )
                    
                    with gr.Column():
                        gr.Markdown("### Bitwise Operations (Coming Soon)")
                        gr.Markdown("""
                        **Available Conversions:**
                        - Decimal ↔ Binary
                        - Decimal ↔ Hexadecimal  
                        - Decimal ↔ Octal
                        - Cross conversions between all bases
                        
                        **Input Formats:**
                        - Decimal: Regular numbers (123)
                        - Binary: Binary string (1010)
                        - Hexadecimal: Hex string (FF or 0xFF)
                        - Octal: Octal string (755 or 0o755)
                        """)
            
            # Engineering Calculator Tab
            with gr.Tab("Engineering"):
                with gr.Row():
                    with gr.Column():
                        engineering_function = gr.Dropdown(
                            ["3ph_impedance"], 
                            label="Engineering Function", 
                            value="3ph_impedance"
                        )
                        
                        gr.Markdown("### 3-Phase Impedance Calculator")
                        gr.Markdown("Calculate equivalent impedance for 5-wire (A,B,C,N,PE) power systems")
                        
                        with gr.Accordion("Conductor Coordinates (feet)", open=True):
                            with gr.Row():
                                coord_a_x = gr.Number(label="Phase A - X", value=0)
                                coord_a_y = gr.Number(label="Phase A - Y", value=42)
                            with gr.Row():
                                coord_b_x = gr.Number(label="Phase B - X", value=23.5)
                                coord_b_y = gr.Number(label="Phase B - Y", value=42)
                            with gr.Row():
                                coord_c_x = gr.Number(label="Phase C - X", value=47)
                                coord_c_y = gr.Number(label="Phase C - Y", value=42)
                            with gr.Row():
                                coord_n_x = gr.Number(label="Neutral - X", value=10)
                                coord_n_y = gr.Number(label="Neutral - Y", value=74)
                            with gr.Row():
                                coord_pe_x = gr.Number(label="PE - X", value=37)
                                coord_pe_y = gr.Number(label="PE - Y", value=72)
                        
                        with gr.Accordion("Conductor Parameters", open=True):
                            with gr.Row():
                                resist_a = gr.Number(label="Phase A Resistance (Ω/mile)", value=0.055)
                                gmr_a = gr.Number(label="Phase A GMR (feet)", value=0.038)
                            with gr.Row():
                                resist_b = gr.Number(label="Phase B Resistance (Ω/mile)", value=0.055)
                                gmr_b = gr.Number(label="Phase B GMR (feet)", value=0.038)
                            with gr.Row():
                                resist_c = gr.Number(label="Phase C Resistance (Ω/mile)", value=0.055)
                                gmr_c = gr.Number(label="Phase C GMR (feet)", value=0.038)
                            with gr.Row():
                                resist_n = gr.Number(label="Neutral Resistance (Ω/mile)", value=8.0)
                                gmr_n = gr.Number(label="Neutral GMR (feet)", value=0.012)
                            with gr.Row():
                                resist_pe = gr.Number(label="PE Resistance (Ω/mile)", value=8.0)
                                gmr_pe = gr.Number(label="PE GMR (feet)", value=0.012)
                        
                        with gr.Row():
                            load_test_btn = gr.Button("Load Test Data")
                            calculate_imp_btn = gr.Button("Calculate Impedance", variant="primary")
                        
                        engineering_result = gr.Textbox(label="Results", lines=20, interactive=False)
                        
                        # Load test data functionality
                        test_data_outputs = [
                            coord_a_x, coord_a_y, coord_b_x, coord_b_y, coord_c_x, coord_c_y,
                            coord_n_x, coord_n_y, coord_pe_x, coord_pe_y,
                            resist_a, gmr_a, resist_b, gmr_b, resist_c, gmr_c,
                            resist_n, gmr_n, resist_pe, gmr_pe
                        ]
                        
                        load_test_btn.click(app.load_test_data, outputs=test_data_outputs)
                        
                        # Calculate impedance functionality
                        impedance_inputs = [
                            coord_a_x, coord_a_y, coord_b_x, coord_b_y, coord_c_x, coord_c_y,
                            coord_n_x, coord_n_y, coord_pe_x, coord_pe_y,
                            resist_a, gmr_a, resist_b, gmr_b, resist_c, gmr_c,
                            resist_n, gmr_n, resist_pe, gmr_pe
                        ]
                        
                        calculate_imp_btn.click(
                            app.calculate_3ph_impedance,
                            inputs=impedance_inputs,
                            outputs=engineering_result
                        )
            
            # AI Chat Tab
            with gr.Tab("AI Assistant"):
                gr.Markdown("### Calculator AI Assistant")
                gr.Markdown("Get help with calculations, mathematical concepts, and engineering problems")
                
                chatbot = gr.Chatbot(label="Chat History", height=400)
                msg = gr.Textbox(label="Your Message", placeholder="Ask me about calculations or math...")
                
                def chat_fn(message, history):
                    return app.chat_with_ai(message, history)
                
                msg.submit(chat_fn, inputs=[msg, chatbot], outputs=[msg, chatbot])
                
                gr.Markdown("""
                **Note:** This is a placeholder for AI integration. In a full implementation, 
                this would connect to an AI service to provide:
                - Help with mathematical concepts
                - Step-by-step calculation guidance  
                - Engineering problem assistance
                - Formula explanations
                """)
    
    return interface

if __name__ == "__main__":
    interface = create_interface()
    interface.launch(server_name="0.0.0.0", server_port=7860, share=False)