from unittest import TestCase
from _pyrepl.content import (
    ContentFragment,
    ContentLine,
    PromptContent,
    SourceLine,
)
from _pyrepl.layout import (
    LayoutMap,
    LayoutRow,
    layout_content_lines,
)


def _source(text, lineno=0, start_offset=0, has_newline=True, cursor_index=None):
    return SourceLine(lineno, text, start_offset, has_newline, cursor_index)


def _prompt(text=">>> ", width=4):
    return PromptContent((), text, width)


def _body_from_text(text):
    return tuple(ContentFragment(ch, 1) for ch in text)


def _content_line(text, prompt=None, has_newline=True, start_offset=0):
    if prompt is None:
        prompt = _prompt()
    body = _body_from_text(text)
    source = _source(text, start_offset=start_offset, has_newline=has_newline)
    return ContentLine(source, prompt, body)


class TestLayoutRow(TestCase):
    def test_width_basic(self):
        row = LayoutRow(4, (1, 1, 1))
        self.assertEqual(row.width, 7)

    def test_width_with_suffix(self):
        row = LayoutRow(4, (1, 1), suffix_width=1)
        self.assertEqual(row.width, 7)

    def test_screeninfo_without_suffix(self):
        row = LayoutRow(4, (1, 1, 1))
        prompt_w, widths = row.screeninfo
        self.assertEqual(prompt_w, 4)
        self.assertEqual(widths, [1, 1, 1])

    def test_screeninfo_with_suffix(self):
        row = LayoutRow(4, (1, 1), suffix_width=1)
        prompt_w, widths = row.screeninfo
        self.assertEqual(prompt_w, 4)
        self.assertEqual(widths, [1, 1, 1])


class TestLayoutMap(TestCase):
    def test_empty(self):
        lm = LayoutMap.empty()
        self.assertEqual(len(lm.rows), 1)
        self.assertEqual(lm.max_row(), 0)
        self.assertEqual(lm.max_column(0), 0)

    def test_screeninfo(self):
        lm = LayoutMap((
            LayoutRow(4, (1, 1, 1)),
            LayoutRow(0, (1, 1)),
        ))
        info = lm.screeninfo
        self.assertEqual(len(info), 2)
        self.assertEqual(info[0], (4, [1, 1, 1]))
        self.assertEqual(info[1], (0, [1, 1]))

    def test_max_column(self):
        lm = LayoutMap((LayoutRow(4, (1, 1, 1)),))
        self.assertEqual(lm.max_column(0), 7)

    def test_max_row(self):
        lm = LayoutMap((LayoutRow(0, ()), LayoutRow(0, ())))
        self.assertEqual(lm.max_row(), 1)

    def test_pos_to_xy_empty_rows(self):
        lm = LayoutMap(())
        self.assertEqual(lm.pos_to_xy(0), (0, 0))

    def test_pos_to_xy_single_row(self):
        lm = LayoutMap((LayoutRow(4, (1, 1, 1), buffer_advance=3),))
        self.assertEqual(lm.pos_to_xy(0), (4, 0))
        self.assertEqual(lm.pos_to_xy(1), (5, 0))
        self.assertEqual(lm.pos_to_xy(2), (6, 0))
        self.assertEqual(lm.pos_to_xy(3), (7, 0))

    def test_pos_to_xy_multi_row(self):
        lm = LayoutMap((
            LayoutRow(4, (1, 1, 1), buffer_advance=4),
            LayoutRow(4, (1, 1), buffer_advance=2),
        ))
        # First row: pos 0-3
        self.assertEqual(lm.pos_to_xy(0), (4, 0))
        self.assertEqual(lm.pos_to_xy(3), (7, 0))
        # Second row: pos 4-5
        self.assertEqual(lm.pos_to_xy(4), (4, 1))
        self.assertEqual(lm.pos_to_xy(5), (5, 1))

    def test_pos_to_xy_past_end_clamps(self):
        lm = LayoutMap((LayoutRow(4, (1, 1), buffer_advance=2),))
        self.assertEqual(lm.pos_to_xy(99), (6, 0))

    def test_pos_to_xy_skips_prompt_only_leading_rows(self):
        lm = LayoutMap((
            LayoutRow(0, (), buffer_advance=0),  # leading prompt-only row
            LayoutRow(4, (1, 1), buffer_advance=3),
        ))
        # pos 0 should skip the leading row and land on the real row
        self.assertEqual(lm.pos_to_xy(0), (4, 1))

    def test_pos_to_xy_with_suffix(self):
        lm = LayoutMap((
            LayoutRow(4, (1, 1), suffix_width=1, buffer_advance=2),
            LayoutRow(0, (1,), buffer_advance=2),
        ))
        # pos=2 fits within first row's char_widths (len=2), cursor at end
        self.assertEqual(lm.pos_to_xy(2), (6, 0))
        # pos=3 exceeds first row, lands on second row
        self.assertEqual(lm.pos_to_xy(3), (1, 1))

    def test_xy_to_pos_empty_rows(self):
        lm = LayoutMap(())
        self.assertEqual(lm.xy_to_pos(0, 0), 0)

    def test_xy_to_pos_single_row(self):
        lm = LayoutMap((LayoutRow(4, (1, 1, 1), buffer_advance=3),))
        self.assertEqual(lm.xy_to_pos(4, 0), 0)
        self.assertEqual(lm.xy_to_pos(5, 0), 1)
        self.assertEqual(lm.xy_to_pos(6, 0), 2)
        self.assertEqual(lm.xy_to_pos(7, 0), 3)

    def test_xy_to_pos_multi_row(self):
        lm = LayoutMap((
            LayoutRow(4, (1, 1, 1), buffer_advance=4),
            LayoutRow(4, (1, 1), buffer_advance=2),
        ))
        self.assertEqual(lm.xy_to_pos(4, 0), 0)
        self.assertEqual(lm.xy_to_pos(4, 1), 4)
        self.assertEqual(lm.xy_to_pos(5, 1), 5)

    def test_xy_to_pos_before_prompt_returns_zero(self):
        lm = LayoutMap((LayoutRow(4, (1, 1), buffer_advance=2),))
        self.assertEqual(lm.xy_to_pos(0, 0), 0)

    def test_xy_to_pos_with_zero_width_chars(self):
        # Simulates combining characters (zero-width) after a base char
        lm = LayoutMap((LayoutRow(4, (1, 0, 1), buffer_advance=3),))
        # x=5 is past the first char; trailing zero-width combining is included
        self.assertEqual(lm.xy_to_pos(5, 0), 2)

    def test_xy_to_pos_zero_width_skipped(self):
        lm = LayoutMap((LayoutRow(0, (0, 1, 1), buffer_advance=3),))
        # x=0: the zero-width char at index 0 is skipped, pos advances
        self.assertEqual(lm.xy_to_pos(0, 0), 1)

    def test_xy_to_pos_zero_width_before_target(self):
        # Zero-width char between two normal chars; target x is past it
        lm = LayoutMap((LayoutRow(0, (1, 0, 1), buffer_advance=3),))
        # x=2: passes char at x=0 (w=1), skips zero-width at x=1, lands at x=2
        self.assertEqual(lm.xy_to_pos(2, 0), 3)

    def test_xy_to_pos_trailing_all_zero_width(self):
        # All remaining chars from cursor position are zero-width
        lm = LayoutMap((LayoutRow(0, (1, 0), buffer_advance=2),))
        # x=1: past first char, trailing loop exhausts (all remaining are 0-width)
        self.assertEqual(lm.xy_to_pos(1, 0), 2)


class TestLayoutContentLines(TestCase):
    def test_zero_width_returns_empty(self):
        result = layout_content_lines((), 0, 0)
        self.assertEqual(result.wrapped_rows, ())
        self.assertEqual(result.layout_map.rows, ())

    def test_negative_width_returns_empty(self):
        result = layout_content_lines((), -1, 0)
        self.assertEqual(result.wrapped_rows, ())

    def test_single_short_line(self):
        line = _content_line("abc")
        result = layout_content_lines((line,), 80, 0)

        self.assertEqual(len(result.wrapped_rows), 1)
        row = result.wrapped_rows[0]
        self.assertEqual(row.prompt_text, ">>> ")
        self.assertEqual(row.prompt_width, 4)
        self.assertEqual(row.suffix, "")
        self.assertEqual(row.buffer_advance, 4)  # 3 chars + newline

    def test_single_line_no_newline(self):
        line = _content_line("ab", has_newline=False)
        result = layout_content_lines((line,), 80, 0)

        self.assertEqual(len(result.wrapped_rows), 1)
        self.assertEqual(result.wrapped_rows[0].buffer_advance, 2)

    def test_empty_body(self):
        source = _source("", has_newline=True)
        prompt = _prompt()
        line = ContentLine(source, prompt, ())
        result = layout_content_lines((line,), 80, 0)

        self.assertEqual(len(result.wrapped_rows), 1)
        self.assertEqual(result.wrapped_rows[0].buffer_advance, 1)  # just newline

    def test_line_wraps(self):
        # prompt ">>> " is 4 wide, terminal is 10 wide, so 6 chars fit per row
        line = _content_line("abcdefgh")  # 8 chars, needs 2 rows
        result = layout_content_lines((line,), 10, 0)

        self.assertEqual(len(result.wrapped_rows), 2)
        first, second = result.wrapped_rows
        self.assertEqual(first.prompt_text, ">>> ")
        self.assertEqual(first.suffix, "\\")
        self.assertEqual(first.suffix_width, 1)
        # First row: 10 - 4(prompt) - 1(suffix) = 5 chars
        self.assertEqual(first.buffer_advance, 5)
        # Second row: continuation with no prompt
        self.assertEqual(second.prompt_text, "")
        self.assertEqual(second.prompt_width, 0)
        self.assertEqual(second.buffer_advance, 4)  # remaining 3 + newline
        self.assertEqual(second.suffix, "")

    def test_wrapping_forces_progress(self):
        # When a single character is wider than available space, force 1 char
        prompt = _prompt("P", 1)
        body = (ContentFragment("W", 1),)
        source = _source("W", has_newline=False)
        line = ContentLine(source, prompt, body)
        # width=2 means prompt(1) + char(1) = 2, which fits (< width would be
        # false for width=2 since 1+1 >= 2), so it wraps but forces progress
        result = layout_content_lines((line,), 2, 0)

        self.assertEqual(len(result.wrapped_rows), 1)
        self.assertEqual(result.wrapped_rows[0].buffer_advance, 1)

    def test_layout_map_matches_wrapped_rows(self):
        line = _content_line("abc")
        result = layout_content_lines((line,), 80, 0)

        self.assertEqual(len(result.layout_map.rows), len(result.wrapped_rows))
        self.assertEqual(result.layout_map.rows[0].prompt_width, 4)
        self.assertEqual(result.layout_map.rows[0].char_widths, (1, 1, 1))

    def test_line_end_offsets(self):
        line1 = _content_line("ab")
        line2 = _content_line("cd")
        result = layout_content_lines((line1, line2), 80, 0)

        self.assertEqual(len(result.line_end_offsets), 2)
        # line1: 2 chars + 1 newline = offset 3
        self.assertEqual(result.line_end_offsets[0], 3)
        # line2: offset 3 + 2 chars + 1 newline = 6
        self.assertEqual(result.line_end_offsets[1], 6)

    def test_start_offset_shifts_offsets(self):
        line = _content_line("ab")
        result = layout_content_lines((line,), 80, 10)

        self.assertEqual(result.line_end_offsets[0], 13)

    def test_multiple_lines(self):
        line1 = _content_line("abc")
        line2 = _content_line("de")
        result = layout_content_lines((line1, line2), 80, 0)

        self.assertEqual(len(result.wrapped_rows), 2)
        self.assertEqual(result.wrapped_rows[0].buffer_advance, 4)  # abc + \n
        self.assertEqual(result.wrapped_rows[1].buffer_advance, 3)  # de + \n

    def test_leading_prompt_lines(self):
        leading = (ContentFragment("header", 6),)
        prompt = PromptContent(leading, ">>> ", 4)
        body = _body_from_text("x")
        source = _source("x", has_newline=False)
        line = ContentLine(source, prompt, body)
        result = layout_content_lines((line,), 80, 0)

        # Leading line + body line
        self.assertEqual(len(result.wrapped_rows), 2)
        # Leading row has the fragment but no prompt
        self.assertEqual(result.wrapped_rows[0].fragments, leading)
        # Body row has prompt and content
        self.assertEqual(result.wrapped_rows[1].prompt_text, ">>> ")

    def test_wrapped_line_layout_rows_have_suffix(self):
        line = _content_line("abcdefgh")
        result = layout_content_lines((line,), 10, 0)

        first_layout = result.layout_map.rows[0]
        self.assertEqual(first_layout.suffix_width, 1)
        second_layout = result.layout_map.rows[1]
        self.assertEqual(second_layout.suffix_width, 0)

    def test_pos_to_xy_through_layout(self):
        line = _content_line("abc")
        result = layout_content_lines((line,), 80, 0)
        lm = result.layout_map

        self.assertEqual(lm.pos_to_xy(0), (4, 0))  # after prompt
        self.assertEqual(lm.pos_to_xy(1), (5, 0))
        self.assertEqual(lm.pos_to_xy(2), (6, 0))
        self.assertEqual(lm.pos_to_xy(3), (7, 0))  # end of line