import os
import os.path

from pr.editor import RPEditor
from pr.multiplexer import close_multiplexer, create_multiplexer, get_multiplexer

from ..tools.patch import display_content_diff
from ..ui.edit_feedback import track_edit, tracker

_editors = {}


def get_editor(filepath):
    if filepath not in _editors:
        _editors[filepath] = RPEditor(filepath)
    return _editors[filepath]


def close_editor(filepath):
    try:
        path = os.path.expanduser(filepath)
        editor = get_editor(path)
        editor.close()

        mux_name = f"editor-{path}"
        mux = get_multiplexer(mux_name)
        if mux:
            mux.write_stdout(f"Closed editor for: {path}\n")
            close_multiplexer(mux_name)

        return {"status": "success", "message": f"Editor closed for {path}"}
    except Exception as e:
        return {"status": "error", "error": str(e)}


def open_editor(filepath):
    try:
        path = os.path.expanduser(filepath)
        editor = RPEditor(path)
        editor.start()

        mux_name = f"editor-{path}"
        mux_name, mux = create_multiplexer(mux_name, show_output=True)
        mux.write_stdout(f"Opened editor for: {path}\n")

        return {
            "status": "success",
            "message": f"Editor opened for {path}",
            "mux_name": mux_name,
        }
    except Exception as e:
        return {"status": "error", "error": str(e)}


def editor_insert_text(filepath, text, line=None, col=None, show_diff=True):
    try:
        path = os.path.expanduser(filepath)

        old_content = ""
        if os.path.exists(path):
            with open(path) as f:
                old_content = f.read()

        position = (line if line is not None else 0) * 1000 + (col if col is not None else 0)
        operation = track_edit("INSERT", filepath, start_pos=position, content=text)
        tracker.mark_in_progress(operation)

        editor = get_editor(path)
        if line is not None and col is not None:
            editor.move_cursor_to(line, col)
        editor.insert_text(text)
        editor.save_file()

        mux_name = f"editor-{path}"
        mux = get_multiplexer(mux_name)
        if mux:
            location = f" at line {line}, col {col}" if line is not None and col is not None else ""
            preview = text[:50] + "..." if len(text) > 50 else text
            mux.write_stdout(f"Inserted text{location}: {repr(preview)}\n")

            if show_diff and old_content:
                with open(path) as f:
                    new_content = f.read()
                diff_result = display_content_diff(old_content, new_content, filepath)
                if diff_result["status"] == "success":
                    mux.write_stdout(diff_result["visual_diff"] + "\n")

        tracker.mark_completed(operation)
        result = {"status": "success", "message": f"Inserted text in {path}"}
        close_editor(filepath)
        return result
    except Exception as e:
        if "operation" in locals():
            tracker.mark_failed(operation)
        return {"status": "error", "error": str(e)}


def editor_replace_text(
    filepath, start_line, start_col, end_line, end_col, new_text, show_diff=True
):
    try:
        path = os.path.expanduser(filepath)

        old_content = ""
        if os.path.exists(path):
            with open(path) as f:
                old_content = f.read()

        start_pos = start_line * 1000 + start_col
        end_pos = end_line * 1000 + end_col
        operation = track_edit(
            "REPLACE",
            filepath,
            start_pos=start_pos,
            end_pos=end_pos,
            content=new_text,
            old_content=old_content,
        )
        tracker.mark_in_progress(operation)

        editor = get_editor(path)
        editor.replace_text(start_line, start_col, end_line, end_col, new_text)
        editor.save_file()

        mux_name = f"editor-{path}"
        mux = get_multiplexer(mux_name)
        if mux:
            preview = new_text[:50] + "..." if len(new_text) > 50 else new_text
            mux.write_stdout(
                f"Replaced text from ({start_line},{start_col}) to ({end_line},{end_col}): {repr(preview)}\n"
            )

            if show_diff and old_content:
                with open(path) as f:
                    new_content = f.read()
                diff_result = display_content_diff(old_content, new_content, filepath)
                if diff_result["status"] == "success":
                    mux.write_stdout(diff_result["visual_diff"] + "\n")

        tracker.mark_completed(operation)
        result = {"status": "success", "message": f"Replaced text in {path}"}
        close_editor(filepath)
        return result
    except Exception as e:
        if "operation" in locals():
            tracker.mark_failed(operation)
        return {"status": "error", "error": str(e)}


def editor_search(filepath, pattern, start_line=0):
    try:
        path = os.path.expanduser(filepath)
        editor = RPEditor(path)
        results = editor.search(pattern, start_line)

        mux_name = f"editor-{path}"
        mux = get_multiplexer(mux_name)
        if mux:
            mux.write_stdout(
                f"Searched for pattern '{pattern}' from line {start_line}: {len(results)} matches\n"
            )

        result = {"status": "success", "results": results}
        close_editor(filepath)
        return result
    except Exception as e:
        return {"status": "error", "error": str(e)}