import Foundation

struct Calculator {
    
    // MARK: - Summenberechnung für Kompetenzen
    
    static func calculateSums(items: [Int]) -> [Int] {
        var sums = [Int](repeating: 0, count: 7) // Index 1-6 werden verwendet
        
        // Kompetenz 1: Arbeitsverhalten (Items 1-10)
        for i in 0..<10 { sums[1] += items[i] }
        
        // Kompetenz 2: Lernverhalten (Items 11-20)
        for i in 10..<20 { sums[2] += items[i] }
        
        // Kompetenz 3: Sozialverhalten (Items 21-28 + Items 9-10)
        for i in 20..<28 { sums[3] += items[i] }
        sums[3] += items[8] + items[9]
        
        // Kompetenz 4: Fachkompetenz (Items 29-36)
        for i in 28..<36 { sums[4] += items[i] }
        
        // Kompetenz 5: Personale Kompetenz
        sums[5] = items[0] + items[1] + items[5] + items[6] + items[7] +
                  items[8] + items[9] + items[11] + items[12] + items[13] + items[14]
        
        // Kompetenz 6: Methodenkompetenz
        sums[6] = items[2] + items[3] + items[4] + items[8] + items[9] +
                  items[10] + items[16] + items[17]
        
        return sums
    }
    
    // MARK: - Profilwertberechnung (0-4 Skala)
    
    static func calculateProfileValues(sums: [Int], norm: [[Double]]) -> [Int] {
        var values = [Int](repeating: 4, count: 6)
        for k in 1...6 {
            for p in 0..<5 {
                if Double(sums[k]) < norm[k-1][p] {
                    values[k-1] = p
                    break
                }
            }
        }
        return values
    }
    
    // MARK: - Korrelation (Pearson)
    
    static func calculateCorrelation(seValues: [Int], feValues: [Int]) -> Double {
        // Auf 1-5 skalieren
        let se = seValues.map { Double($0 + 1) }
        let fe = feValues.map { Double($0 + 1) }
        
        let seMean = se.reduce(0, +) / 6
        let feMean = fe.reduce(0, +) / 6
        
        var numerator = 0.0
        var seVar = 0.0
        var feVar = 0.0
        
        for i in 0..<6 {
            let seDiff = se[i] - seMean
            let feDiff = fe[i] - feMean
            numerator += seDiff * feDiff
            seVar += seDiff * seDiff
            feVar += feDiff * feDiff
        }
        
        if seVar == 0 || feVar == 0 { return 0 }
        return numerator / sqrt(seVar * feVar)
    }
    
    // MARK: - Prozentuale Übereinstimmung
    
    static func calculateAgreement(seItems: [Int], feItems: [Int]) -> Double {
        var matches = 0
        for i in 0..<36 {
            if seItems[i] == feItems[i] { matches += 1 }
        }
        return Double(matches) * 100.0 / 36
    }
    
    // MARK: - T-Wert Berechnung (M=50, SD=10)
    
    static func calculateTValue(rawScore: Int, mean: Double, sd: Double) -> Int {
        return Int(50 + 10 * ((Double(rawScore) - mean) / sd))
    }
    
    // MARK: - Prozentrang Berechnung
    
    static func calculatePercentile(rawScore: Int, normTable: [Double]) -> Int {
        for (index, value) in normTable.enumerated() {
            if Double(rawScore) <= value {
                let percentiles = [5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 95]
                return percentiles[min(index, percentiles.count - 1)]
            }
        }
        return 99
    }
    
    // MARK: - Bewertungstext
    
    static func getRating(value: Int) -> String {
        switch value {
        case 1: return "weit unterdurchschnittlich"
        case 2: return "unterdurchschnittlich"
        case 3: return "durchschnittlich"
        case 4: return "überdurchschnittlich"
        case 5: return "weit überdurchschnittlich"
        default: return "unbekannt"
        }
    }
    
    // MARK: - Interpretationstext
    
    static func getInterpretation(correlation: Double, agreement: Double, seValues: [Int], feValues: [Int]) -> String {
        var text = ""
        
        // Korrelations-Interpretation
        if correlation >= 0.8 {
            text += "Sehr gute Übereinstimmung zwischen Selbst- und Fremdeinschätzung (r = \(String(format: "%.2f", correlation))).\n\n"
        } else if correlation >= 0.6 {
            text += "Gute Übereinstimmung zwischen Selbst- und Fremdeinschätzung (r = \(String(format: "%.2f", correlation))).\n\n"
        } else if correlation >= 0.4 {
            text += "Mäßige Übereinstimmung zwischen Selbst- und Fremdeinschätzung (r = \(String(format: "%.2f", correlation))).\n\n"
        } else if correlation >= 0.2 {
            text += "Schwache Übereinstimmung zwischen Selbst- und Fremdeinschätzung (r = \(String(format: "%.2f", correlation))).\n\n"
        } else {
            text += "Keine signifikante Übereinstimmung zwischen Selbst- und Fremdeinschätzung (r = \(String(format: "%.2f", correlation))).\n\n"
        }
        
        // Prozentuale Übereinstimmung
        text += "Die inhaltliche Übereinstimmung beträgt \(String(format: "%.1f", agreement))%.\n\n"
        
        // Stärken und Schwächen
        text += "Auswertung der Kompetenzen:\n"
        text += "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
        text += "Selbsteinschätzung:\n"
        for i in 0..<6 {
            let rating = seValues[i] + 1
            text += "  • \(Norms.kompetenzen[i]): \(getRating(value: rating)) (Wert: \(rating)/5)\n"
        }
        
        text += "\nFremdeinschätzung:\n"
        for i in 0..<6 {
            let rating = feValues[i] + 1
            text += "  • \(Norms.kompetenzen[i]): \(getRating(value: rating)) (Wert: \(rating)/5)\n"
        }
        
        return text
    }
}