//
//  EngineeringCalculatorViewController.swift
//  Swift iOS Calculator
//
//  Created by RSK World on 23/01/2026.
//  Copyright © 2026 RSK World. All rights reserved.
//
//  Developer: Molla Samser (Founder, RSK World)
//  Designer & Tester: Rima Khatun
//  Contact: info@rskworld.com, +91 93305 39277
//  Website: https://rskworld.in
//  Address: Nutanhat, Mongolkote, Purba Burdwan, West Bengal, India - 713147
//

import UIKit

class EngineeringCalculatorViewController: UIViewController {
    
    // MARK: - Outlets
    @IBOutlet weak var calculatorSegmentedControl: UISegmentedControl!
    @IBOutlet weak var inputContainerView: UIView!
    @IBOutlet weak var resultTextView: UITextView!
    @IBOutlet weak var calculateButton: UIButton!
    @IBOutlet weak var clearButton: UIButton!
    
    // Circuit Analysis Outlets
    @IBOutlet weak var voltageTextField: UITextField!
    @IBOutlet weak var currentTextField: UITextField!
    @IBOutlet weak var resistanceTextField: UITextField!
    @IBOutlet weak var capacitanceTextField: UITextField!
    @IBOutlet weak var inductanceTextField: UITextField!
    @IBOutlet weak var frequencyTextField: UITextField!
    
    // Material Properties Outlets
    @IBOutlet weak var stressTextField: UITextField!
    @IBOutlet weak var strainTextField: UITextField!
    @IBOutlet weak var youngsModulusTextField: UITextField!
    @IBOutlet weak var forceTextField: UITextField!
    @IBOutlet weak var areaTextField: UITextField!
    @IBOutlet weak var lengthTextField: UITextField!
    
    // Fluid Mechanics Outlets
    @IBOutlet weak var flowRateTextField: UITextField!
    @IBOutlet weak var pipeDiameterTextField: UITextField!
    @IBOutlet weak var velocityTextField: UITextField!
    @IBOutlet weak var pressureDropTextField: UITextField!
    @IBOutlet weak viscosityTextField: UITextField!
    
    // Thermodynamics Outlets
    @IBOutlet weak var workTextField: UITextField!
    @IBOutlet weak var heatTextField: UITextField!
    @IBOutlet weak var efficiencyTextField: UITextField!
    @IBOutlet weak var powerTextField: UITextField!
    
    // Structural Analysis Outlets
    @IBOutlet weak var beamLengthTextField: UITextField!
    @IBOutlet weak var loadTextField: UITextField!
    @IBOutlet weak deflectionTextField: UITextField!
    @IBOutlet weak var momentOfInertiaTextField: UITextField!
    
    // MARK: - Properties
    private var currentCalculator: EngineeringCalculatorType = .circuits
    private let engineeringCalculator = EngineeringCalculatorService()
    
    enum EngineeringCalculatorType: String, CaseIterable {
        case circuits = "Circuits"
        case materials = "Materials"
        case fluids = "Fluids"
        case thermodynamics = "Thermodynamics"
        case structural = "Structural"
        case mechanical = "Mechanical"
        
        var icon: String {
            switch self {
            case .circuits: return "cpu"
            case .materials: return "cube"
            case .fluids: return "drop"
            case .thermodynamics: return "thermometer"
            case .structural: return "building.2"
            case .mechanical: return "gearshape.2"
            }
        }
    }
    
    // MARK: - Lifecycle
    override func viewDidLoad() {
        super.viewDidLoad()
        setupUI()
        setupSegmentedControl()
        setupInputViews()
        showCircuitsInputs()
    }
    
    // MARK: - Setup
    private func setupUI() {
        title = "Engineering Calculator"
        view.backgroundColor = CalculatorTheme.shared.backgroundColor
        
        // Setup result text view
        resultTextView.backgroundColor = CalculatorTheme.shared.displayBackgroundColor
        resultTextView.textColor = CalculatorTheme.shared.textColor
        resultTextView.layer.cornerRadius = 12
        resultTextView.layer.borderWidth = 2
        resultTextView.layer.borderColor = CalculatorTheme.shared.accentColor.cgColor
        resultTextView.font = UIFont.systemFont(ofSize: 16, weight: .medium)
        resultTextView.isEditable = false
        
        // Setup buttons
        setupButton(calculateButton, title: "Calculate", color: .systemGreen)
        setupButton(clearButton, title: "Clear", color: .systemRed)
    }
    
    private func setupButton(_ button: UIButton, title: String, color: UIColor) {
        button.setTitle(title, for: .normal)
        button.backgroundColor = color
        button.setTitleColor(.white, for: .normal)
        button.layer.cornerRadius = 8
        button.titleLabel?.font = UIFont.systemFont(ofSize: 16, weight: .medium)
    }
    
    private func setupSegmentedControl() {
        calculatorSegmentedControl.removeAllSegments()
        for (index, type) in EngineeringCalculatorType.allCases.enumerated() {
            calculatorSegmentedControl.insertSegment(withTitle: type.rawValue, at: index, animated: false)
        }
        calculatorSegmentedControl.selectedSegmentIndex = 0
        calculatorSegmentedControl.backgroundColor = CalculatorTheme.shared.buttonBackgroundColor
        calculatorSegmentedControl.selectedSegmentTintColor = CalculatorTheme.shared.accentColor
        calculatorSegmentedControl.setTitleTextAttributes([NSAttributedString.Key.foregroundColor: CalculatorTheme.shared.textColor], for: .normal)
        calculatorSegmentedControl.setTitleTextAttributes([NSAttributedString.Key.foregroundColor: UIColor.white], for: .selected)
    }
    
    private func setupInputViews() {
        // Setup all text fields with consistent styling
        let textFields = [
            voltageTextField, currentTextField, resistanceTextField, capacitanceTextField, inductanceTextField, frequencyTextField,
            stressTextField, strainTextField, youngsModulusTextField, forceTextField, areaTextField, lengthTextField,
            flowRateTextField, pipeDiameterTextField, velocityTextField, pressureDropTextField, viscosityTextField,
            workTextField, heatTextField, efficiencyTextField, powerTextField,
            beamLengthTextField, loadTextField, deflectionTextField, momentOfInertiaTextField
        ].compactMap { $0 }
        
        for textField in textFields {
            textField.backgroundColor = CalculatorTheme.shared.displayBackgroundColor
            textField.textColor = CalculatorTheme.shared.textColor
            textField.layer.cornerRadius = 8
            textField.layer.borderWidth = 1
            textField.layer.borderColor = CalculatorTheme.shared.buttonBackgroundColor.cgColor
            textField.textAlignment = .center
            textField.font = UIFont.systemFont(ofSize: 16)
            textField.keyboardType = .decimalPad
        }
    }
    
    // MARK: - Actions
    @IBAction func calculatorChanged(_ sender: UISegmentedControl) {
        currentCalculator = EngineeringCalculatorType.allCases[sender.selectedSegmentIndex]
        switchToCalculator(currentCalculator)
    }
    
    @IBAction func calculateButtonPressed(_ sender: UIButton) {
        performCalculation()
    }
    
    @IBAction func clearButtonPressed(_ sender: UIButton) {
        clearAllInputs()
    }
    
    // MARK: - Methods
    private func switchToCalculator(_ type: EngineeringCalculatorType) {
        hideAllInputViews()
        
        switch type {
        case .circuits:
            showCircuitsInputs()
        case .materials:
            showMaterialsInputs()
        case .fluids:
            showFluidsInputs()
        case .thermodynamics:
            showThermodynamicsInputs()
        case .structural:
            showStructuralInputs()
        case .mechanical:
            showMechanicalInputs()
        }
        
        clearResult()
    }
    
    private func hideAllInputViews() {
        inputContainerView.subviews.forEach { $0.isHidden = true }
    }
    
    private func showCircuitsInputs() {
        voltageTextField.isHidden = false
        currentTextField.isHidden = false
        resistanceTextField.isHidden = false
        capacitanceTextField.isHidden = false
        inductanceTextField.isHidden = false
        frequencyTextField.isHidden = false
        
        voltageTextField.placeholder = "Voltage (V)"
        currentTextField.placeholder = "Current (A)"
        resistanceTextField.placeholder = "Resistance (Ω)"
        capacitanceTextField.placeholder = "Capacitance (F)"
        inductanceTextField.placeholder = "Inductance (H)"
        frequencyTextField.placeholder = "Frequency (Hz)"
    }
    
    private func showMaterialsInputs() {
        stressTextField.isHidden = false
        strainTextField.isHidden = false
        youngsModulusTextField.isHidden = false
        forceTextField.isHidden = false
        areaTextField.isHidden = false
        lengthTextField.isHidden = false
        
        stressTextField.placeholder = "Stress (Pa)"
        strainTextField.placeholder = "Strain"
        youngsModulusTextField.placeholder = "Young's Modulus (Pa)"
        forceTextField.placeholder = "Force (N)"
        areaTextField.placeholder = "Area (m²)"
        lengthTextField.placeholder = "Length (m)"
    }
    
    private func showFluidsInputs() {
        flowRateTextField.isHidden = false
        pipeDiameterTextField.isHidden = false
        velocityTextField.isHidden = false
        pressureDropTextField.isHidden = false
        viscosityTextField.isHidden = false
        
        flowRateTextField.placeholder = "Flow Rate (m³/s)"
        pipeDiameterTextField.placeholder = "Pipe Diameter (m)"
        velocityTextField.placeholder = "Velocity (m/s)"
        pressureDropTextField.placeholder = "Pressure Drop (Pa)"
        viscosityTextField.placeholder = "Viscosity (Pa·s)"
    }
    
    private func showThermodynamicsInputs() {
        workTextField.isHidden = false
        heatTextField.isHidden = false
        efficiencyTextField.isHidden = false
        powerTextField.isHidden = false
        
        workTextField.placeholder = "Work (J)"
        heatTextField.placeholder = "Heat (J)"
        efficiencyTextField.placeholder = "Efficiency (%)"
        powerTextField.placeholder = "Power (W)"
    }
    
    private func showStructuralInputs() {
        beamLengthTextField.isHidden = false
        loadTextField.isHidden = false
        deflectionTextField.isHidden = false
        momentOfInertiaTextField.isHidden = false
        
        beamLengthTextField.placeholder = "Beam Length (m)"
        loadTextField.placeholder = "Load (N)"
        deflectionTextField.placeholder = "Deflection (m)"
        momentOfInertiaTextField.placeholder = "Moment of Inertia (m⁴)"
    }
    
    private func showMechanicalInputs() {
        forceTextField.isHidden = false
        velocityTextField.isHidden = false
        powerTextField.isHidden = false
        torqueTextField.isHidden = false
        
        forceTextField.placeholder = "Force (N)"
        velocityTextField.placeholder = "Velocity (m/s)"
        powerTextField.placeholder = "Power (W)"
        torqueTextField.placeholder = "Torque (N·m)"
    }
    
    private func performCalculation() {
        view.endEditing(true)
        
        switch currentCalculator {
        case .circuits:
            calculateCircuits()
        case .materials:
            calculateMaterials()
        case .fluids:
            calculateFluids()
        case .thermodynamics:
            calculateThermodynamics()
        case .structural:
            calculateStructural()
        case .mechanical:
            calculateMechanical()
        }
    }
    
    private func calculateCircuits() {
        let voltage = Double(voltageTextField.text ?? "")
        let current = Double(currentTextField.text ?? "")
        let resistance = Double(resistanceTextField.text ?? "")
        let capacitance = Double(capacitanceTextField.text ?? "")
        let inductance = Double(inductanceTextField.text ?? "")
        let frequency = Double(frequencyTextField.text ?? "")
        
        let result = engineeringCalculator.calculateCircuits(
            voltage: voltage,
            current: current,
            resistance: resistance,
            capacitance: capacitance,
            inductance: inductance,
            frequency: frequency
        )
        displayResult(result)
    }
    
    private func calculateMaterials() {
        let stress = Double(stressTextField.text ?? "")
        let strain = Double(strainTextField.text ?? "")
        let youngsModulus = Double(youngsModulusTextField.text ?? "")
        let force = Double(forceTextField.text ?? "")
        let area = Double(areaTextField.text ?? "")
        let length = Double(lengthTextField.text ?? "")
        
        let result = engineeringCalculator.calculateMaterials(
            stress: stress,
            strain: strain,
            youngsModulus: youngsModulus,
            force: force,
            area: area,
            length: length
        )
        displayResult(result)
    }
    
    private func calculateFluids() {
        let flowRate = Double(flowRateTextField.text ?? "")
        let pipeDiameter = Double(pipeDiameterTextField.text ?? "")
        let velocity = Double(velocityTextField.text ?? "")
        let pressureDrop = Double(pressureDropTextField.text ?? "")
        let viscosity = Double(viscosityTextField.text ?? "")
        
        let result = engineeringCalculator.calculateFluids(
            flowRate: flowRate,
            pipeDiameter: pipeDiameter,
            velocity: velocity,
            pressureDrop: pressureDrop,
            viscosity: viscosity
        )
        displayResult(result)
    }
    
    private func calculateThermodynamics() {
        let work = Double(workTextField.text ?? "")
        let heat = Double(heatTextField.text ?? "")
        let efficiency = Double(efficiencyTextField.text ?? "")
        let power = Double(powerTextField.text ?? "")
        
        let result = engineeringCalculator.calculateThermodynamics(
            work: work,
            heat: heat,
            efficiency: efficiency,
            power: power
        )
        displayResult(result)
    }
    
    private func calculateStructural() {
        let beamLength = Double(beamLengthTextField.text ?? "")
        let load = Double(loadTextField.text ?? "")
        let deflection = Double(deflectionTextField.text ?? "")
        let momentOfInertia = Double(momentOfInertiaTextField.text ?? "")
        
        let result = engineeringCalculator.calculateStructural(
            beamLength: beamLength,
            load: load,
            deflection: deflection,
            momentOfInertia: momentOfInertia
        )
        displayResult(result)
    }
    
    private func calculateMechanical() {
        let force = Double(forceTextField.text ?? "")
        let velocity = Double(velocityTextField.text ?? "")
        let power = Double(powerTextField.text ?? "")
        let torque = Double(torqueTextField.text ?? "")
        
        let result = engineeringCalculator.calculateMechanical(
            force: force,
            velocity: velocity,
            power: power,
            torque: torque
        )
        displayResult(result)
    }
    
    private func displayResult(_ result: EngineeringCalculationResult) {
        let resultText = formatResult(result)
        resultTextView.text = resultText
        
        // Animate result appearance
        resultTextView.alpha = 0
        UIView.animate(withDuration: 0.5) {
            self.resultTextView.alpha = 1
        }
        
        // Save to history
        saveToHistory(result: resultText)
    }
    
    private func formatResult(_ result: EngineeringCalculationResult) -> String {
        var formattedResult = ""
        
        switch result {
        case .circuits(let power, let impedance, let reactance):
            formattedResult = """
            ⚡ Circuit Analysis
            
            Results:
            • Power: \(String(format: "%.2f", power)) W
            • Impedance: \(String(format: "%.2f", impedance)) Ω
            • Reactance: \(String(format: "%.2f", reactance)) Ω
            
            Formulas:
            • Power = V × I
            • Impedance = √(R² + (XL - XC)²)
            • Reactance = XL - XC
            """
            
        case .materials(let stress, let strain, let youngsModulus):
            formattedResult = """
            🔩 Material Properties
            
            Results:
            • Stress: \(String(format: "%.2f", stress)) Pa
            • Strain: \(String(format: "%.6f", strain))
            • Young's Modulus: \(String(format: "%.2f", youngsModulus)) Pa
            
            Formulas:
            • Stress = Force / Area
            • Strain = ΔL / L
            • Young's Modulus = Stress / Strain
            """
            
        case .fluids(let reynoldsNumber, let reynoldsType):
            formattedResult = """
            💧 Fluid Mechanics
            
            Results:
            • Reynolds Number: \(String(format: "%.0f", reynoldsNumber))
            • Flow Type: \(reynoldsType)
            
            Formulas:
            • Reynolds Number = (ρ × v × D) / μ
            • Laminar: Re < 2300
            • Turbulent: Re > 4000
            """
            
        case .thermodynamics(let efficiency, let cop):
            formattedResult = """
            🌡️ Thermodynamics
            
            Results:
            • Efficiency: \(String(format: "%.2f", efficiency))%
            • COP: \(String(format: "%.2f", cop))
            
            Formulas:
            • Efficiency = (Work Output / Heat Input) × 100%
            • COP = Heat Output / Work Input
            """
            
        case .structural(let maxStress, let safetyFactor):
            formattedResult = """
            🏗️ Structural Analysis
            
            Results:
            • Maximum Stress: \(String(format: "%.2f", maxStress)) Pa
            • Safety Factor: \(String(format: "%.2f", safetyFactor))
            
            Formulas:
            • Max Stress = (M × c) / I
            • Safety Factor = Yield Strength / Working Stress
            """
            
        case .mechanical(let power, let torque, let efficiency):
            formattedResult = """
            ⚙️ Mechanical Engineering
            
            Results:
            • Power: \(String(format: "%.2f", power)) W
            • Torque: \(String(format: "%.2f", torque)) N·m
            • Efficiency: \(String(format: "%.2f", efficiency))%
            
            Formulas:
            • Power = Force × Velocity
            • Torque = Force × Radius
            • Efficiency = (Output Power / Input Power) × 100%
            """
        }
        
        return formattedResult
    }
    
    private func clearAllInputs() {
        let textFields = [
            voltageTextField, currentTextField, resistanceTextField, capacitanceTextField, inductanceTextField, frequencyTextField,
            stressTextField, strainTextField, youngsModulusTextField, forceTextField, areaTextField, lengthTextField,
            flowRateTextField, pipeDiameterTextField, velocityTextField, pressureDropTextField, viscosityTextField,
            workTextField, heatTextField, efficiencyTextField, powerTextField,
            beamLengthTextField, loadTextField, deflectionTextField, momentOfInertiaTextField
        ].compactMap { $0 }
        
        for textField in textFields {
            textField.text = ""
        }
        
        clearResult()
    }
    
    private func clearResult() {
        resultTextView.text = "Results will appear here..."
    }
    
    private func saveToHistory(result: String) {
        let historyItem = CalculationHistoryItem(
            expression: "\(currentCalculator.rawValue) Calculation",
            result: result,
            category: "Engineering Calculator",
            date: Date()
        )
        
        CalculationHistoryManager.shared.addHistoryItem(historyItem)
    }
    
    private func showError(_ message: String) {
        let alert = UIAlertController(title: "Error", message: message, preferredStyle: .alert)
        alert.addAction(UIAlertAction(title: "OK", style: .default))
        present(alert, animated: true)
    }
}

// MARK: - Engineering Calculator Service
class EngineeringCalculatorService {
    
    func calculateCircuits(voltage: Double?, current: Double?, resistance: Double?, capacitance: Double?, inductance: Double?, frequency: Double?) -> EngineeringCalculationResult {
        var calculatedPower = 0.0
        var calculatedImpedance = 0.0
        var calculatedReactance = 0.0
        
        if let voltage = voltage, let current = current {
            calculatedPower = voltage * current
        }
        
        if let resistance = resistance, let capacitance = capacitance, let inductance = inductance, let frequency = frequency {
            let omega = 2 * Double.pi * frequency
            let capacitiveReactance = 1 / (omega * capacitance)
            let inductiveReactance = omega * inductance
            calculatedReactance = inductiveReactance - capacitiveReactance
            calculatedImpedance = sqrt(resistance * resistance + calculatedReactance * calculatedReactance)
        }
        
        return .circuits(power: calculatedPower, impedance: calculatedImpedance, reactance: calculatedReactance)
    }
    
    func calculateMaterials(stress: Double?, strain: Double?, youngsModulus: Double?, force: Double?, area: Double?, length: Double?) -> EngineeringCalculationResult {
        var calculatedStress = stress ?? 0.0
        var calculatedStrain = strain ?? 0.0
        var calculatedYoungsModulus = youngsModulus ?? 0.0
        
        if let force = force, let area = area {
            calculatedStress = force / area
        }
        
        if let stress = stress, let youngsModulus = youngsModulus {
            calculatedStrain = stress / youngsModulus
        }
        
        if let stress = stress, let strain = strain, strain != 0 {
            calculatedYoungsModulus = stress / strain
        }
        
        return .materials(stress: calculatedStress, strain: calculatedStrain, youngsModulus: calculatedYoungsModulus)
    }
    
    func calculateFluids(flowRate: Double?, pipeDiameter: Double?, velocity: Double?, pressureDrop: Double?, viscosity: Double?) -> EngineeringCalculationResult {
        var reynoldsNumber = 0.0
        var reynoldsType = "Unknown"
        
        if let velocity = velocity, let pipeDiameter = pipeDiameter, let viscosity = viscosity {
            let density = 1000.0 // kg/m³ (water)
            reynoldsNumber = (density * velocity * pipeDiameter) / viscosity
            
            if reynoldsNumber < 2300 {
                reynoldsType = "Laminar Flow"
            } else if reynoldsNumber > 4000 {
                reynoldsType = "Turbulent Flow"
            } else {
                reynoldsType = "Transitional Flow"
            }
        }
        
        return .fluids(reynoldsNumber: reynoldsNumber, reynoldsType: reynoldsType)
    }
    
    func calculateThermodynamics(work: Double?, heat: Double?, efficiency: Double?, power: Double?) -> EngineeringCalculationResult {
        var calculatedEfficiency = efficiency ?? 0.0
        var calculatedCOP = 0.0
        
        if let work = work, let heat = heat, heat != 0 {
            calculatedEfficiency = (work / heat) * 100
            calculatedCOP = heat / work
        }
        
        return .thermodynamics(efficiency: calculatedEfficiency, cop: calculatedCOP)
    }
    
    func calculateStructural(beamLength: Double?, load: Double?, deflection: Double?, momentOfInertia: Double?) -> EngineeringCalculationResult {
        var maxStress = 0.0
        var safetyFactor = 0.0
        
        if let load = load, let beamLength = beamLength {
            // Simple cantilever beam calculation
            maxStress = (load * beamLength) / (momentOfInertia ?? 1e-6)
            let yieldStrength = 250e6 // Pa (mild steel)
            safetyFactor = yieldStrength / maxStress
        }
        
        return .structural(maxStress: maxStress, safetyFactor: safetyFactor)
    }
    
    func calculateMechanical(force: Double?, velocity: Double?, power: Double?, torque: Double?) -> EngineeringCalculationResult {
        var calculatedPower = power ?? 0.0
        var calculatedTorque = torque ?? 0.0
        var calculatedEfficiency = 0.0
        
        if let force = force, let velocity = velocity {
            calculatedPower = force * velocity
        }
        
        if let power = power, let velocity = velocity, velocity != 0 {
            calculatedTorque = power / velocity
        }
        
        calculatedEfficiency = min(calculatedPower / 1000, 100) // Simplified efficiency
        
        return .mechanical(power: calculatedPower, torque: calculatedTorque, efficiency: calculatedEfficiency)
    }
}

// MARK: - Supporting Types
enum EngineeringCalculationResult {
    case circuits(power: Double, impedance: Double, reactance: Double)
    case materials(stress: Double, strain: Double, youngsModulus: Double)
    case fluids(reynoldsNumber: Double, reynoldsType: String)
    case thermodynamics(efficiency: Double, cop: Double)
    case structural(maxStress: Double, safetyFactor: Double)
    case mechanical(power: Double, torque: Double, efficiency: Double)
}

// Missing outlet for mechanical calculator
extension EngineeringCalculatorViewController {
    @IBOutlet weak var torqueTextField: UITextField!
}