package com.duesk;

import javax.swing.*;
import javax.swing.table.AbstractTableModel;
import java.awt.*;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.category.DefaultCategoryDataset;
import com.duesk.api.models.Profile;
import com.duesk.api.models.Norms;
import com.duesk.utils.Calculator;

public class ProfileDetailDialog extends JDialog {
    private Profile profile;
    private String currentNorm = "HS";
    private int[] seValues;
    private int[] feValues;
    
    private JTable seTable;
    private JTable feTable;
    private JTable itemsTable;
    private JLabel correlationLabel;
    private JLabel agreementLabel;
    private JTextArea interpretationArea;
    private ChartPanel seChartPanel;
    private ChartPanel feChartPanel;
    private ChartPanel statsChartPanel;
    
    public ProfileDetailDialog(JFrame parent, Profile profile) {
        super(parent, "Profil: " + profile.getName(), true);
        this.profile = profile;
        setSize(1000, 800);
        setLocationRelativeTo(parent);
        
        initComponents();
        calculate();
    }
    
    private void initComponents() {
        setLayout(new BorderLayout());
        
        // Oberer Bereich mit Name und Normauswahl
        JPanel topPanel = new JPanel(new BorderLayout());
        JLabel nameLabel = new JLabel("Name: " + profile.getName());
        nameLabel.setFont(new Font("Arial", Font.BOLD, 14));
        topPanel.add(nameLabel, BorderLayout.WEST);
        
        JPanel normPanel = new JPanel();
        ButtonGroup normGroup = new ButtonGroup();
        JRadioButton hsRb = new JRadioButton("Hauptschule (HS)", true);
        JRadioButton fsRb = new JRadioButton("Förderschule (FS)", false);
        normGroup.add(hsRb);
        normGroup.add(fsRb);
        
        hsRb.addActionListener(e -> {
            currentNorm = "HS";
            calculate();
        });
        fsRb.addActionListener(e -> {
            currentNorm = "FS";
            calculate();
        });
        
        normPanel.add(new JLabel("Normtabelle:"));
        normPanel.add(hsRb);
        normPanel.add(fsRb);
        topPanel.add(normPanel, BorderLayout.EAST);
        
        add(topPanel, BorderLayout.NORTH);
        
        // TabbedPane
        JTabbedPane tabbedPane = new JTabbedPane();
        
        // SE Tab
        JPanel sePanel = createCompetencePanel(true);
        tabbedPane.addTab("Selbsteinschätzung", sePanel);
        
        // FE Tab
        JPanel fePanel = createCompetencePanel(false);
        tabbedPane.addTab("Fremdeinschätzung", fePanel);
        
        // Statistik Tab
        JPanel statsPanel = createStatsPanel();
        tabbedPane.addTab("Statistik", statsPanel);
        
        // Items Tab
        JPanel itemsPanel = createItemsPanel();
        tabbedPane.addTab("Alle Items", itemsPanel);
        
        add(tabbedPane, BorderLayout.CENTER);
        
        // Schließen Button
        JButton closeBtn = new JButton("Schließen");
        closeBtn.addActionListener(e -> dispose());
        JPanel bottomPanel = new JPanel();
        bottomPanel.add(closeBtn);
        add(bottomPanel, BorderLayout.SOUTH);
    }
    
    private JPanel createCompetencePanel(boolean isSE) {
        JPanel panel = new JPanel(new BorderLayout());
        
        // Tabelle
        CompetenceTableModel tableModel = new CompetenceTableModel(isSE);
        JTable table = new JTable(tableModel);
        table.setRowHeight(25);
        if (isSE) seTable = table;
        else feTable = table;
        
        panel.add(new JScrollPane(table), BorderLayout.CENTER);
        
        // Diagramm
        seChartPanel = new ChartPanel(null);
        feChartPanel = new ChartPanel(null);
        panel.add(isSE ? seChartPanel : feChartPanel, BorderLayout.SOUTH);
        
        return panel;
    }
    
    private JPanel createStatsPanel() {
        JPanel panel = new JPanel(new BorderLayout());
        
        // Vergleichsdiagramm
        statsChartPanel = new ChartPanel(null);
        panel.add(statsChartPanel, BorderLayout.NORTH);
        
        // Statistik-Labels
        JPanel statsPanel = new JPanel(new GridLayout(2, 1));
        correlationLabel = new JLabel();
        agreementLabel = new JLabel();
        correlationLabel.setFont(new Font("Arial", Font.BOLD, 12));
        agreementLabel.setFont(new Font("Arial", Font.BOLD, 12));
        statsPanel.add(correlationLabel);
        statsPanel.add(agreementLabel);
        panel.add(statsPanel, BorderLayout.CENTER);
        
        // Interpretation
        interpretationArea = new JTextArea();
        interpretationArea.setEditable(false);
        interpretationArea.setLineWrap(true);
        interpretationArea.setWrapStyleWord(true);
        JScrollPane scrollPane = new JScrollPane(interpretationArea);
        scrollPane.setPreferredSize(new Dimension(800, 150));
        panel.add(scrollPane, BorderLayout.SOUTH);
        
        return panel;
    }
    
    private JPanel createItemsPanel() {
        JPanel panel = new JPanel(new BorderLayout());
        
        ItemsTableModel itemsModel = new ItemsTableModel();
        itemsTable = new JTable(itemsModel);
        itemsTable.setRowHeight(20);
        panel.add(new JScrollPane(itemsTable), BorderLayout.CENTER);
        
        return panel;
    }
    
    private void calculate() {
        // Items extrahieren
        int[] seItems = new int[36];
        int[] feItems = new int[36];
        for (int i = 1; i <= 36; i++) {
            seItems[i-1] = profile.getItem(i);
            feItems[i-1] = profile.getFeItem(i);
        }
        
        // Summen berechnen
        int[] seSums = Calculator.calculateSums(seItems);
        int[] feSums = Calculator.calculateSums(feItems);
        
        // Normen auswählen
        double[][] normSE, normFE;
        if (currentNorm.equals("HS")) {
            normSE = Norms.NORM_SE_HS;
            normFE = Norms.NORM_FE_HS;
        } else {
            normSE = Norms.NORM_SE_FS;
            normFE = Norms.NORM_FE_FS;
        }
        
        // Profilwerte berechnen
        seValues = Calculator.calculateProfileValues(seSums, normSE);
        feValues = Calculator.calculateProfileValues(feSums, normFE);
        
        // Tabellen aktualisieren
        if (seTable != null) seTable.repaint();
        if (feTable != null) feTable.repaint();
        if (itemsTable != null) itemsTable.repaint();
        
        // Diagramme aktualisieren
        updateCharts();
        
        // Statistik
        double correlation = Calculator.calculateCorrelation(seValues, feValues);
        double agreement = Calculator.calculateAgreement(seItems, feItems);
        
        correlationLabel.setText(String.format("Korrelation: %.2f", correlation));
        agreementLabel.setText(String.format("Übereinstimmung: %.1f%%", agreement));
        
        // Interpretation
        StringBuilder sb = new StringBuilder();
        sb.append("Die Korrelation von ").append(String.format("%.2f", correlation)).append(" bedeutet: ");
        if (correlation >= 0.8) sb.append("Sehr gute Übereinstimmung zwischen Selbst- und Fremdeinschätzung.\n\n");
        else if (correlation >= 0.5) sb.append("Mäßige Übereinstimmung zwischen Selbst- und Fremdeinschätzung.\n\n");
        else if (correlation >= 0.3) sb.append("Schwache Übereinstimmung zwischen Selbst- und Fremdeinschätzung.\n\n");
        else sb.append("Keine signifikante Übereinstimmung zwischen Selbst- und Fremdeinschätzung.\n\n");
        
        sb.append("Auswertung der Kompetenzen:\n");
        sb.append("--------------------------------------------------\n");
        sb.append("Selbsteinschätzung:\n");
        for (int i = 0; i < 6; i++) {
            sb.append("  • ").append(Norms.KOMPETENZEN[i]).append(": ")
              .append(Calculator.getRating(seValues[i] + 1)).append("\n");
        }
        sb.append("\nFremdeinschätzung:\n");
        for (int i = 0; i < 6; i++) {
            sb.append("  • ").append(Norms.KOMPETENZEN[i]).append(": ")
              .append(Calculator.getRating(feValues[i] + 1)).append("\n");
        }
        interpretationArea.setText(sb.toString());
    }
    
    private void updateCharts() {
        // SE Diagramm
        DefaultCategoryDataset seDataset = new DefaultCategoryDataset();
        for (int i = 0; i < 6; i++) {
            seDataset.addValue(seValues[i] + 1, "SE", Norms.KOMPETENZEN[i]);
        }
        JFreeChart seChart = ChartFactory.createLineChart(
            "Selbsteinschätzung", "Kompetenz", "Wert", seDataset,
            PlotOrientation.VERTICAL, true, true, false);
        seChartPanel.setChart(seChart);
        
        // FE Diagramm
        DefaultCategoryDataset feDataset = new DefaultCategoryDataset();
        for (int i = 0; i < 6; i++) {
            feDataset.addValue(feValues[i] + 1, "FE", Norms.KOMPETENZEN[i]);
        }
        JFreeChart feChart = ChartFactory.createLineChart(
            "Fremdeinschätzung", "Kompetenz", "Wert", feDataset,
            PlotOrientation.VERTICAL, true, true, false);
        feChartPanel.setChart(feChart);
        
        // Vergleichsdiagramm
        DefaultCategoryDataset statsDataset = new DefaultCategoryDataset();
        for (int i = 0; i < 6; i++) {
            statsDataset.addValue(seValues[i] + 1, "Selbsteinschätzung (SE)", Norms.KOMPETENZEN[i]);
            statsDataset.addValue(feValues[i] + 1, "Fremdeinschätzung (FE)", Norms.KOMPETENZEN[i]);
        }
        JFreeChart statsChart = ChartFactory.createLineChart(
            "Vergleich SE vs FE", "Kompetenz", "Wert", statsDataset,
            PlotOrientation.VERTICAL, true, true, false);
        statsChartPanel.setChart(statsChart);
    }
    
    private class CompetenceTableModel extends AbstractTableModel {
        private boolean isSE;
        
        CompetenceTableModel(boolean isSE) { this.isSE = isSE; }
        
        @Override
        public int getRowCount() { return 6; }
        @Override
        public int getColumnCount() { return 6; }
        @Override
        public String getColumnName(int col) { return col == 0 ? "Kompetenz" : String.valueOf(col); }
        
        @Override
        public Object getValueAt(int row, int col) {
            if (col == 0) return Norms.KOMPETENZEN[row];
            int value = isSE ? seValues[row] : feValues[row];
            return value == col - 1 ? "X" : "";
        }
    }
    
    private class ItemsTableModel extends AbstractTableModel {
        private final String[] columns = {"Item", "SE", "FE"};
        
        @Override
        public int getRowCount() { return 36; }
        @Override
        public int getColumnCount() { return 3; }
        @Override
        public String getColumnName(int col) { return columns[col]; }
        
        @Override
        public Object getValueAt(int row, int col) {
            switch (col) {
                case 0: return Norms.ITEMS[row];
                case 1: return profile.getItem(row + 1);
                case 2: return profile.getFeItem(row + 1);
                default: return null;
            }
        }
    }
}