import logging
from textual.app import ComposeResult
from textual.widgets import Static, Footer
from textual.binding import Binding
from textual import on
from textual.reactive import reactive
from textual.screen import Screen
from pathlib import Path
from typing import List, Optional, Dict, Callable

from atomic_assembler.constants import BORDER_STYLE, PRIMARY_COLOR, Mode
from atomic_assembler.widgets.generic_list import GenericList
from atomic_assembler.widgets.new_item_input import NewItemInput
from atomic_assembler.widgets.confirmation_modal import ConfirmationModal

from textual.message import Message


class FileExplorerScreen(Screen):
    """Screen for exploring files and directories."""

    class FileSelected(Message):
        """Message emitted when a file is selected."""

        def __init__(self, path: Path) -> None:
            self.path = path
            super().__init__()

    CSS = f"""
    Screen {{
        align: center middle;
    }}

    #title {{
        dock: top;
        padding: 1 2;
        color: $text;
        text-align: center;
        text-style: bold;
        border: solid {PRIMARY_COLOR};
    }}

    #current-path {{
        padding: 1 2;
    }}

    Footer {{
        color: $text;
    }}

    .modal-overlay {{
        width: 100%;
        height: 100%;
        background: rgba(0, 0, 0, 0.5);
        layout: grid;
        grid-size: 1;
        align: center middle;
    }}
    """

    BINDINGS = [
        Binding("escape", "handle_escape", "Exit/Cancel", show=True),
        Binding("n", "new_folder", "New Folder"),
        Binding("f", "new_file", "New File"),
        Binding("left", "go_up_folder", "Go Up", show=True, priority=True),
        Binding("right", "enter_folder", "Enter Folder", show=True, priority=True),
        Binding("enter", "action_select", "Select Item", show=True),
    ]

    current_path: reactive[Path] = reactive(Path.cwd())
    new_item_mode: reactive[bool] = reactive(False)
    selected_file: Optional[Path] = None
    directory_selections: Dict[Path, Optional[Path]] = {}

    def __init__(
        self,
        allowed_extensions: Optional[List[str]] = None,
        enable_folder_creation: bool = True,
        enable_file_creation: bool = True,
        mode: Mode = Mode.FILE_MODE,
        callback: Optional[Callable[[Path], None]] = None,
        title: str = "File Picker",  # New title parameter
        *args,
        **kwargs,
    ):
        """Initialize the FileExplorerScreen."""
        super().__init__(*args, **kwargs)
        self.mode = mode
        self.callback = callback
        self.title_widget = Static(title, id="title")  # Use the title parameter
        self.current_path_widget = Static("", id="current-path")
        self.file_list = GenericList(item_renderer=self._render_file_item)
        self.new_item_input = NewItemInput(id="new-item-input")
        self.footer = Footer()
        self.allowed_extensions = allowed_extensions
        self.enable_folder_creation = enable_folder_creation
        self.enable_file_creation = enable_file_creation
        logging.info("FileExplorerScreen initialized")

    def compose(self) -> ComposeResult:
        """Compose the layout of the screen."""
        yield self.title_widget
        yield self.current_path_widget
        yield self.file_list
        yield self.new_item_input
        yield self.footer

    def on_mount(self):
        """Handler called when the screen is mounted."""
        logging.info("FileExplorerScreen mounted")
        self.refresh_file_list()
        self.border_color = BORDER_STYLE.split()[-1]

    def watch_current_path(self, path: Path):
        """React to changes in the current_path."""
        logging.info(f"Current path changed to: {path}")
        self.refresh_file_list()

    def refresh_file_list(self):
        """Refresh the file list and update the current path display."""
        logging.debug("Refreshing file list")
        self.update_current_path_display()
        items = self._get_file_items()
        self.file_list.update_list(items)

        # Set highlighted index based on stored selection for current directory
        selected_path = self.directory_selections.get(self.current_path)
        if selected_path:
            for index, item in enumerate(items):
                if item["path"] == selected_path:
                    self.file_list.set_highlighted_index(index)
                    break
            else:
                self.file_list.set_highlighted_index(0)
        else:
            self.file_list.set_highlighted_index(0)

    def update_current_path_display(self):
        """Update the display of the current path."""
        self.current_path_widget.update(f"Current directory: [bold {PRIMARY_COLOR}]{self.current_path}[/bold {PRIMARY_COLOR}]")

    @on(GenericList.Highlighted)
    def on_highlighted(self, list_view):
        logging.info(f"Highlighted item: {list_view.item}")
        if list_view.item:
            # self.current_path = str(list_view.highlighted_item.item_data["path"])
            self.current_path_widget.update(
                f"Current directory: [bold {PRIMARY_COLOR}]{list_view.item.item_data['path']}[/bold {PRIMARY_COLOR}]"
            )

    def _get_file_items(self):
        """Get the list of file items to display."""
        items = []
        for item in sorted(self.current_path.iterdir(), key=lambda x: (not x.is_dir(), x.name.lower())):
            if self.mode == Mode.DIRECTORY_MODE and item.is_file():
                continue  # Skip files in directory mode
            if self._is_allowed_file(item):
                items.append({"path": item, "is_dir": item.is_dir(), "is_parent": False})
        return items

    def _is_allowed_file(self, path: Path) -> bool:
        """Check if the file is allowed based on its extension or name."""
        if path.is_dir():
            return True
        if self.allowed_extensions is None:
            return True

        # Convert allowed extensions to lowercase for case-insensitive comparison
        allowed_exts = [ext.lower() for ext in self.allowed_extensions]

        # Check if the file name (without extension) is in allowed extensions
        # This handles cases like '.env'
        if path.stem.lower() in allowed_exts:
            return True

        # Check if the file extension (including the dot) is in allowed extensions
        if path.suffix.lower() in [f".{ext}" for ext in allowed_exts]:
            return True

        return False

    def _render_file_item(self, item: dict) -> str:
        """Render a file item."""
        icon = "📁 " if item["is_dir"] else "📄 "
        name = ".." if item["is_parent"] else item["path"].name
        return f"{icon}{name}"

    def on_generic_list_item_selected(self, message: GenericList.ItemSelected):
        """Handle item selection from GenericList."""
        item = message.item
        self.handle_item_selection(item)

    def handle_item_selection(self, item: dict):
        """Handle the selection of an item based on the current mode."""
        if (self.mode == Mode.DIRECTORY_MODE and item["is_dir"]) or (self.mode == Mode.FILE_MODE and not item["is_dir"]):
            self.selected_file = item["path"]
            item_type = "folder" if item["is_dir"] else "file"
            logging.info(f"{item_type.capitalize()} selected: {self.selected_file}")
            self.app.push_screen(
                ConfirmationModal(
                    f"Are you sure you want to select this {item_type}: {self.selected_file.name}?",
                    self.handle_confirmation,
                )
            )
        else:
            logging.info("No valid selection made.")

    def action_enter_folder(self):
        """Action to enter the selected folder."""
        highlighted_item = self.file_list.highlighted_child
        if not highlighted_item:
            return
        selected_item = highlighted_item.item_data
        if selected_item and selected_item["is_dir"]:
            # Store the current selection before changing directory
            self.directory_selections[self.current_path] = selected_item["path"]
            self.current_path = selected_item["path"]
            logging.info(f"Entered directory: {self.current_path}")

    def action_select(self):
        """Override the select action to handle Enter key press."""
        highlighted_item = self.file_list.highlighted_child
        if highlighted_item:
            self.handle_item_selection(highlighted_item.item_data)

    def handle_confirmation(self, confirmed: bool):
        """Handle the result of the confirmation modal."""
        logging.info(f"Confirmation result: {confirmed}")
        if confirmed and self.selected_file:
            logging.info(f"Selection confirmed: {self.selected_file}")
            if self.callback:
                logging.info(f"Calling callback with selected file: {self.selected_file}")
                self.app.pop_screen()  # Pop the screen after callback

                self.callback(self.selected_file)  # Ensure this is called
        else:
            logging.info("Selection cancelled")
            self.selected_file = None

    def action_new_folder(self):
        """Action to enter new folder creation mode."""
        logging.info("Entering new folder creation mode")
        self.new_item_mode = True
        self.new_item_input.display = True
        self.file_list.disabled = True
        self.new_item_input.placeholder = "Enter folder name"
        self.new_item_input.focus()

    def action_new_file(self):
        """Action to enter new file creation mode."""
        logging.info("Entering new file creation mode")
        self.new_item_mode = True
        self.new_item_input.display = True
        self.file_list.disabled = True
        self.new_item_input.placeholder = "Enter file name"
        self.new_item_input.focus()

    def create_new_item(self, item_name: str):
        """Create a new item based on the input."""
        logging.info(f"Attempting to create new item: {item_name}")
        if item_name:
            new_item_path = self.current_path / item_name
            try:
                if self.new_item_input.placeholder == "Enter folder name":
                    new_item_path.mkdir(parents=True, exist_ok=False)
                    logging.info(f"New directory created: {new_item_path}")
                else:
                    new_item_path.touch(exist_ok=False)
                    logging.info(f"New file created: {new_item_path}")
                self.refresh_file_list()
            except FileExistsError:
                logging.warning(f"Failed to create item, already exists: {new_item_path}")
                self.bell()
            finally:
                self.new_item_input.value = ""
        self.exit_new_item_mode()

    def exit_new_item_mode(self):
        """Exit the new item creation mode."""
        logging.info("Exiting new item mode")
        self.new_item_mode = False
        self.new_item_input.display = False
        self.file_list.disabled = False
        self.file_list.focus()
        self.refresh_bindings()

    def on_new_item_input_submitted(self, message: NewItemInput.Submitted):
        """Handle the submission of the new item input."""
        item_name = message.value
        self.create_new_item(item_name)

    def on_new_item_input_cancelled(self, message: NewItemInput.Cancelled):
        """Handle the cancellation of the new item input."""
        self.exit_new_item_mode()

    def action_handle_escape(self):
        """Handle the escape key."""
        if self.new_item_mode:
            logging.info("Exiting new item mode via escape key")
            self.exit_new_item_mode()
        else:
            logging.info("Popping screen via escape key")
            self.app.pop_screen()

    def action_go_up_folder(self):
        """Action to go up one folder."""
        if self.current_path != self.current_path.root:
            # Store the current selection before going up
            highlighted_item = self.file_list.highlighted_child
            if highlighted_item:
                self.directory_selections[self.current_path] = highlighted_item.item_data["path"]
            self.current_path = self.current_path.parent
            logging.info(f"Moved up to directory: {self.current_path}")

    def check_action(self, action: str, parameters: tuple[object, ...]) -> bool | None:
        """
        Check if an action may run / be displayed in the footer.
        """
        can_run = None

        if action == "new_folder":
            can_run = self.enable_folder_creation and not self.new_item_mode
        elif action == "new_file":
            can_run = self.enable_file_creation and not self.new_item_mode and self.mode == Mode.FILE_MODE  # Check mode
        elif action == "handle_escape":
            can_run = True
        elif action in ["go_up_folder", "enter_folder"]:
            can_run = not self.new_item_mode

        return can_run  # Return the final value