package cvbuilder.view;

import cvbuilder.controller.CsvExportSettings;
import cvbuilder.model.Address;
import cvbuilder.model.User;
import cvbuilder.model.UserGroup;

import javax.swing.*;
import java.awt.*;
import java.io.*;
import java.util.*;


public class MainViewer {

    private final UserGroup userGroup;

    public MainViewer() {
        userGroup = UserGroup.getInstance();

        // Create the main frame
        JFrame viewer = new JFrame("CV Builder");
        viewer.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        viewer.setSize(800, 500);

        // Create menu bar
        JMenuBar menuBar = new JMenuBar();
        JMenu menu = new JMenu("Menu");
        menuBar.add(menu);
        viewer.setJMenuBar(menuBar);

        // Set up the Open and Save menu items
        setupMenu(viewer);

        // Add content to the frame
        populateMainPanel(viewer);

        // Make the frame visible after all content is added
        viewer.setVisible(true);
    }

    private void populateMainPanel(JFrame viewer) {
        JTabbedPane outer = new JTabbedPane();
        JTabbedPane userT = new JTabbedPane();
        JTabbedPane contactT = new JTabbedPane();

        // User tab
        JPanel title = new JPanel();
        title.setName("title");
        JPanel name = new JPanel();
        name.setName("name");
        JPanel email = new JPanel();
        email.setName("email");

        populatePanel(title);
        populatePanel(name);
        populatePanel(email);

        userT.addTab("Title", title);
        userT.addTab("Name", name);
        userT.addTab("Email", email);
        outer.addTab("User", userT);

        // Contact tab
        JPanel phone = new JPanel();
        phone.setName("phone");
        JPanel address = new JPanel();
        address.setName("address");

        populatePanel(phone);
        populatePanel(address);

        contactT.addTab("Phone", phone);
        contactT.addTab("Address", address);
        outer.addTab("Contact", contactT);

        // Create main container with BorderLayout
        JPanel mainContainer = new JPanel(new BorderLayout());
        mainContainer.add(outer, BorderLayout.CENTER);

        // Add footer with navigation buttons
        JPanel footer = createFooter(outer);
        mainContainer.add(footer, BorderLayout.SOUTH);

        viewer.getContentPane().add(mainContainer);
        viewer.revalidate();
    }

    private void populatePanel(JPanel panel) {

        String panelName = panel.getName();
        String titleName = panelName.substring(0, 1).toUpperCase() + panelName.substring(1);
        panel.setBorder(BorderFactory.createTitledBorder(
                BorderFactory.createEtchedBorder(), titleName
        ));

        panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
        ButtonGroup group = new ButtonGroup();

        // Add "Include in CSV" checkbox at the top - but NOT for name or email panels
        if (!panelName.equalsIgnoreCase("name") && !panelName.equalsIgnoreCase("email")) {
            JPanel includePanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
            JCheckBox includeCheckbox = new JCheckBox("Include in CSV");
            includeCheckbox.setSelected(true); // Default to selected
            includePanel.add(includeCheckbox);

            // Store selection in the CsvExportSettings
            includeCheckbox.addActionListener(e -> {
                boolean include = includeCheckbox.isSelected();
                System.out.println("Include " + panelName + " in CSV: " + include);
                CsvExportSettings.getInstance().setInclude(panelName, include);
            });

            panel.add(includePanel);
            panel.add(Box.createVerticalStrut(5));
            panel.add(new JSeparator(JSeparator.HORIZONTAL));
            panel.add(Box.createVerticalStrut(10));
        } else {
            // For name and email, always set them to be included without showing checkbox
            CsvExportSettings.getInstance().setInclude(panelName, true);
        }

        if (userGroup.getUsers().isEmpty()) {
            panel.add(new JLabel("No users available"));
            return;
        }

        // Add existing users
        for (int i = 0; i < userGroup.getUsers().size(); i++) {
            User user = userGroup.getUsers().get(i);
            String value = user.getUserAttribute(panelName);

            // Format address display if this is the address panel
            String displayValue = value;
            if (panelName.equalsIgnoreCase("address")) {
                Address address = user.getAddress();
                displayValue = address.getDisplayFormat();
            }

            if (value != null && !value.isEmpty()) {
                // Create a panel for each entry with radio button and action buttons
                JPanel entryPanel = new JPanel();
                entryPanel.setLayout(new BoxLayout(entryPanel, BoxLayout.X_AXIS));

                // Create radio button with properly formatted display value
                JRadioButton radioButton = new JRadioButton(displayValue);
                group.add(radioButton);
                entryPanel.add(radioButton);

                // Add some spacing
                entryPanel.add(Box.createHorizontalStrut(10));

                // Create Edit button
                JButton editButton = new JButton("Edit");
                final int userIndex = i;
                editButton.addActionListener(e -> {
                    String newValue;
                    if (panelName.equalsIgnoreCase("address")) {
                        newValue = showAddressDialog("Edit " + panelName, value);
                    } else {
                        newValue = showDialog("Edit " + panelName, value);
                    }
                    if (newValue != null && !newValue.isEmpty()) {
                        // Update the user attribute
                        switch (panelName.toLowerCase()) {
                            case "title" -> user.setTitle(newValue);
                            case "name" -> user.setName(newValue);
                            case "email" -> user.setEmail(newValue);
                            case "phone" -> user.setPhone(newValue);
                            case "address" -> user.setAddress(newValue);
                        }

                        // Update the radio button label with properly formatted value
                        if (panelName.equalsIgnoreCase("address")) {
                            radioButton.setText(user.getAddress().getDisplayFormat());
                        } else {
                            radioButton.setText(newValue);
                        }
                    }
                });
                entryPanel.add(editButton);

                // Add some spacing
                entryPanel.add(Box.createHorizontalStrut(5));

                // Create delete button
                JButton deleteButton = new JButton("Delete");
                deleteButton.addActionListener(e -> {
                    // Remove the user without confirmation
                    userGroup.getUsers().remove(userIndex);

                    // Refresh all panels
                    JFrame frame = (JFrame) SwingUtilities.getWindowAncestor(panel);
                    frame.getContentPane().removeAll();
                    populateMainPanel(frame);
                    frame.revalidate();
                    frame.repaint();
                });
                entryPanel.add(deleteButton);

                // Add padding to align elements
                entryPanel.add(Box.createHorizontalGlue());

                // Add the entry panel to the main panel
                panel.add(entryPanel);
            }
        }

        // Add a separator
        panel.add(Box.createVerticalStrut(20));
        panel.add(new JSeparator(JSeparator.HORIZONTAL));
        panel.add(Box.createVerticalStrut(10));

        // Add the "Add Row" interface at the bottom
        JPanel addRowPanel = new JPanel();
        addRowPanel.setLayout(new BoxLayout(addRowPanel, BoxLayout.X_AXIS));
        addRowPanel.setMaximumSize(new Dimension(Integer.MAX_VALUE, 80));

        JTextField newValueField = new JTextField(15);
        JButton addButton = new JButton("Add Row");

        addRowPanel.add(new JLabel("New " + panelName + ": "));
        addRowPanel.add(newValueField);
        addRowPanel.add(Box.createHorizontalStrut(10));
        addRowPanel.add(addButton);

        // Add row action
        addButton.addActionListener(e -> {
            String newValue = newValueField.getText().trim();
            if (!newValue.isEmpty()) {
                // Create a new user
                User newUser = new User();

                // Set all attributes to "Unknown" by default
                newUser.setName("Unknown");
                newUser.setTitle("Unknown");
                newUser.setEmail("Unknown");
                newUser.setPhone("Unknown");
                newUser.setAddress("Unknown");

                // Set the specific attribute from the input field
                switch (panelName.toLowerCase()) {
                    case "title" -> newUser.setTitle(newValue);
                    case "name" -> newUser.setName(newValue);
                    case "email" -> newUser.setEmail(newValue);
                    case "phone" -> newUser.setPhone(newValue);
                    case "address" -> newUser.setAddress(newValue);
                }

                // Add the new user to the group
                userGroup.addUser(newUser);

                // Refresh all panels
                JFrame frame = (JFrame) SwingUtilities.getWindowAncestor(panel);
                frame.getContentPane().removeAll();
                populateMainPanel(frame);
                frame.revalidate();
                frame.repaint();

                // Clear the input field
                newValueField.setText("");
            } else {
                JOptionPane.showMessageDialog(panel,
                        "Please enter a value for the new " + panelName,
                        "Empty Value", JOptionPane.WARNING_MESSAGE);
            }
        });

        panel.add(addRowPanel);

        // Add vertical glue to push all components to the top
        panel.add(Box.createVerticalGlue());
    }

    private String showDialog(String title, String initialValue) {
        JTextField textField = new JTextField(initialValue);
        JLabel label = new JLabel("Enter new text:");

        JPanel panel = new JPanel();
        panel.setLayout(new GridLayout(0, 1));

        panel.add(label);
        panel.add(textField);

        JOptionPane pane = new JOptionPane(panel, JOptionPane.PLAIN_MESSAGE, JOptionPane.OK_CANCEL_OPTION);
        JDialog dialog = pane.createDialog("Rename Dialogue Box");
        dialog.setVisible(true);

        // Process the user's choice
        Object value = pane.getValue();
        if (value instanceof Integer) {
            int choice = (Integer) value;

            if (choice == JOptionPane.OK_OPTION) {
                String newValue = textField.getText().trim();
                System.out.println("OK option pressed and set text to: " + newValue + " for tab: " + title);
                return newValue;
            } else if (choice == JOptionPane.CANCEL_OPTION) {
                System.out.println("Cancel option pressed for tab: " + title);
            }
        }

        dialog.dispose();
        return null;
    }

    private String showAddressDialog(String title, String initialValue) {
        JTextField flatField = new JTextField();
        JTextField addressLine1Field = new JTextField();
        JTextField addressLine2Field = new JTextField();
        JTextField postcodeField = new JTextField();

        // Use the Address class to parse the address string
        Address address = new Address(initialValue);

        // Set field values from the Address object
        flatField.setText(address.getFlat());
        addressLine1Field.setText(address.getAddressLine1());
        addressLine2Field.setText(address.getAddressLine2());
        postcodeField.setText(address.getPostcode());

        JPanel panel = new JPanel(new GridLayout(0, 1));
        panel.add(new JLabel("Flat (optional):"));
        panel.add(flatField);
        panel.add(new JLabel("Address line 1:"));
        panel.add(addressLine1Field);
        panel.add(new JLabel("Address line 2 (optional):"));
        panel.add(addressLine2Field);
        panel.add(new JLabel("Postcode:"));
        panel.add(postcodeField);

        int result = JOptionPane.showConfirmDialog(null, panel, title, JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE);
        if (result == JOptionPane.OK_OPTION) {
            String newFlat = flatField.getText().trim();
            String newAddressLine1 = addressLine1Field.getText().trim();
            String newAddressLine2 = addressLine2Field.getText().trim();
            String newPostcode = postcodeField.getText().trim();

            // Create an Address object with the new values
            Address newAddress = new Address("");
            newAddress.setFlat(newFlat);
            newAddress.setAddressLine1(newAddressLine1);
            newAddress.setAddressLine2(newAddressLine2);
            newAddress.setPostcode(newPostcode);

            // Return the CSV format of the address
            return newAddress.getCsvFormat();
        }
        return null;
    }

    private JPanel createFooter(JTabbedPane tabbedPane) {
        JPanel footer = new JPanel(new BorderLayout());
        footer.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));

        JButton prevButton = new JButton("Previous Section");
        JButton nextButton = new JButton("Next Section");

        // Style the buttons
        prevButton.setFocusPainted(false);
        nextButton.setFocusPainted(false);

        // Add action listeners
        prevButton.addActionListener(e -> {
            int currentIndex = tabbedPane.getSelectedIndex();
            if (currentIndex > 0) {
                tabbedPane.setSelectedIndex(currentIndex - 1);
            }
        });

        nextButton.addActionListener(e -> {
            int currentIndex = tabbedPane.getSelectedIndex();
            if (currentIndex < tabbedPane.getTabCount() - 1) {
                tabbedPane.setSelectedIndex(currentIndex + 1);
            }
        });

        // Add buttons to footer
        footer.add(prevButton, BorderLayout.WEST);
        footer.add(nextButton, BorderLayout.EAST);

        return footer;
    }

    private void setupMenu(JFrame viewer) {
        JMenuBar menuBar = viewer.getJMenuBar();
        JMenu menu = menuBar.getMenu(0); // Get the existing "Menu" menu

        // Create Open menu item
        JMenuItem openItem = new JMenuItem("Open");
        openItem.addActionListener(e -> openCsvFile(viewer));

        // Create Save menu item
        JMenuItem saveItem = new JMenuItem("Save");
        saveItem.addActionListener(e -> saveCsvFile(viewer));

        menu.add(new JSeparator());
        menu.add(openItem);
        menu.add(saveItem);
    }

    // Class variable to store the current CSV file path -- added default file data
    private String currentCsvFile = "data/cv_repo_0.csv";

    private void openCsvFile(JFrame viewer) {
        JFileChooser fileChooser = new JFileChooser();
        fileChooser.setDialogTitle("Open CSV File");
        fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
        fileChooser.setFileFilter(new javax.swing.filechooser.FileFilter() {
            public boolean accept(File f) {
                return f.isDirectory() || f.getName().toLowerCase().endsWith(".csv");
            }
            public String getDescription() {
                return "CSV Files (*.csv)";
            }
        });

        int result = fileChooser.showOpenDialog(viewer);
        if (result == JFileChooser.APPROVE_OPTION) {
            File selectedFile = fileChooser.getSelectedFile();
            loadCsvFile(selectedFile.getAbsolutePath(), viewer);
        }
    }

    private void loadCsvFile(String filePath, JFrame viewer) {
        UserGroup userGroup = UserGroup.getInstance();
        userGroup.clearUsers(); // Clear existing users

        try (BufferedReader r = new BufferedReader(new FileReader(filePath))) {
            // Skip the first line (Section,Sub-Section,Variants)
            r.readLine();

            // Read all lines into memory so we can process by column
            String[] lines = r.lines().toArray(String[]::new);

            // First pass: determine maximum number of users
            int maxUserCount = 0;
            for (String line : lines) {
                String[] parts = line.split(",");
                int userCount = parts.length - 2; // Subtract first two columns
                maxUserCount = Math.max(maxUserCount, userCount);
            }

            // Create all users with default "Unknown" values
            for (int i = 0; i < maxUserCount; i++) {
                User user = new User();
                user.setName("Unknown");
                user.setTitle("Unknown");
                user.setEmail("Unknown");
                user.setPhone("Unknown");
                user.setAddress("Unknown");
                userGroup.addUser(user);
            }

            // Second pass: fill in actual values where available
            for (String line : lines) {
                String[] parts = line.split(",");

                if (parts.length < 3) continue;

                String sectionType = parts[0] + "," + parts[1];

                // Process each user column (starting from column 2, index 2)
                for (int colIndex = 2; colIndex < parts.length; colIndex++) {
                    int userIndex = colIndex - 2; // User index starts from 0
                    if (userIndex < userGroup.getUsers().size()) {
                        User user = userGroup.getUsers().get(userIndex);
                        String value = parts[colIndex].trim();

                        // Only update if the value is not empty
                        if (!value.isEmpty()) {
                            switch (sectionType) {
                                case "User,Name" -> user.setName(value);
                                case "User,Title" -> user.setTitle(value);
                                case "User,Email" -> user.setEmail(value);
                                case "Contact Information,Phone" -> user.setPhone(value);
                                case "Contact Information,Address" -> user.setAddress(value);
                            }
                        }
                    }
                }
            }

            // Store the current file path
            currentCsvFile = filePath;

            // Refresh the UI
            viewer.getContentPane().removeAll();
            populateMainPanel(viewer);
            viewer.revalidate();
            viewer.repaint();

            System.out.println("Loaded " + maxUserCount + " users from " + filePath);
        } catch (IOException e) {
            JOptionPane.showMessageDialog(viewer,
                    "Error loading CSV file: " + e.getMessage(),
                    "File Error",
                    JOptionPane.ERROR_MESSAGE);
        }
    }

    private void saveCsvFile(JFrame viewer) {
        if (currentCsvFile == null) {
            // No file loaded yet, show save dialog
            JFileChooser fileChooser = new JFileChooser();
            fileChooser.setDialogTitle("Save CSV File");
            fileChooser.setFileFilter(new javax.swing.filechooser.FileFilter() {
                public boolean accept(File f) {
                    return f.isDirectory() || f.getName().toLowerCase().endsWith(".csv");
                }
                public String getDescription() {
                    return "CSV Files (*.csv)";
                }
            });

            int result = fileChooser.showSaveDialog(viewer);
            if (result == JFileChooser.APPROVE_OPTION) {
                File selectedFile = fileChooser.getSelectedFile();
                String path = selectedFile.getAbsolutePath();
                if (!path.toLowerCase().endsWith(".csv")) {
                    path += ".csv";
                }
                currentCsvFile = path;
                writeToCSV(currentCsvFile);
            }
        } else {
            // Use the existing file path
            writeToCSV(currentCsvFile);
        }
    }

    private void writeToCSV(String filePath) {
        // First read the existing file to preserve data for sections not included
        Map<String, String[]> existingData = new HashMap<>();
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            // Skip the header
            reader.readLine();

            String line;
            while ((line = reader.readLine()) != null) {
                String[] parts = line.split(",", 3); // Split into section, subsection, and the rest
                if (parts.length >= 2) {
                    String key = parts[0] + "," + parts[1];
                    // Store the whole line
                    existingData.put(key, line.split(","));
                }
            }
        } catch (IOException e) {
            // If file doesn't exist or can't be read, we'll create a new one
            // No need to handle this exception
        }

        try (PrintWriter writer = new PrintWriter(new FileWriter(filePath))) {
            // Get export settings
            CsvExportSettings exportSettings = CsvExportSettings.getInstance();

            // Write header
            writer.println("Section,Sub-Section,Variants");

            // Get all users
            UserGroup userGroup = UserGroup.getInstance();

            // Build user data strings to append - we'll use these if the section should be included
            String[] nameData = new String[userGroup.getUsers().size()];
            String[] titleData = new String[userGroup.getUsers().size()];
            String[] emailData = new String[userGroup.getUsers().size()];
            String[] phoneData = new String[userGroup.getUsers().size()];
            String[] addressData = new String[userGroup.getUsers().size()];

            for (int i = 0; i < userGroup.getUsers().size(); i++) {
                User user = userGroup.getUsers().get(i);
                nameData[i] = user.getName();
                titleData[i] = user.getTitle();
                emailData[i] = user.getEmail();
                phoneData[i] = user.getPhone();
                addressData[i] = user.getAddress().getCsvFormat();
            }

            // Process and write each section based on inclusion settings

            // Name - always included
            writeSection(writer, existingData, "User,Name", nameData, true);

            // Title - conditionally included
            writeSection(writer, existingData, "User,Title", titleData, exportSettings.isIncluded("title"));

            // Email - always included
            writeSection(writer, existingData, "User,Email", emailData, true);

            // Phone - conditionally included
            writeSection(writer, existingData, "Contact Information,Phone", phoneData, exportSettings.isIncluded("phone"));

            // Address - conditionally included
            writeSection(writer, existingData, "Contact Information,Address", addressData, exportSettings.isIncluded("address"));

        } catch (IOException e) {
            JOptionPane.showMessageDialog(null,
                    "Error saving CSV file: " + e.getMessage(),
                    "File Error",
                    JOptionPane.ERROR_MESSAGE);
        }
    }

    private void writeSection(PrintWriter writer, Map<String, String[]> existingData, String section,
                              String[] userData, boolean include) {
        if (include) {
            // This section should be updated with new data
            writer.print(section);
            for (String data : userData) {
                writer.print("," + data);
            }
            writer.println();
        } else if (existingData.containsKey(section)) {
            // This section should be preserved as-is
            String[] parts = existingData.get(section);
            writer.print(parts[0] + "," + parts[1]); // Section and Sub-Section

            // Add the remaining data columns
            for (int i = 2; i < parts.length; i++) {
                writer.print("," + parts[i]);
            }
            writer.println();
        }
    }

}