# -*- coding: utf-8 -*-
"""
Property-based tests for analysis-dashboard-redesign features.
Uses hypothesis with max_examples=100 as specified in the design document.

Run: python -m pytest tests/test_dashboard_properties.py -v
"""

import os
import sys
import re
import json
import tempfile

# Ensure project root is on path
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

import pytest
import pandas as pd
from hypothesis import given, settings, assume
from hypothesis import strategies as st
from hypothesis.extra.pandas import column, data_frames, range_indexes


# ---------------------------------------------------------------------------
# Helpers / Strategies
# ---------------------------------------------------------------------------

# Strategy for generating random execution results (success or failure)
execution_result_st = st.fixed_dictionaries({
    "success": st.booleans(),
    "output": st.text(min_size=0, max_size=200),
    "error": st.text(min_size=0, max_size=200),
    "variables": st.just({}),
    "evidence_rows": st.lists(
        st.dictionaries(
            keys=st.text(min_size=1, max_size=10, alphabet="abcdefghijklmnopqrstuvwxyz"),
            values=st.one_of(st.integers(), st.text(min_size=0, max_size=20), st.floats(allow_nan=False)),
            min_size=1,
            max_size=5,
        ),
        min_size=0,
        max_size=10,
    ),
    "auto_exported_files": st.just([]),
    "prompt_saved_files": st.just([]),
})

# Strategy for reasoning text (may be empty, simulating missing YAML field)
reasoning_st = st.one_of(st.just(""), st.text(min_size=1, max_size=200))

# Strategy for code text
code_st = st.text(min_size=1, max_size=500, alphabet="abcdefghijklmnopqrstuvwxyz0123456789 =()._\n")

# Strategy for feedback/raw_log text
feedback_st = st.text(min_size=0, max_size=300)


def build_round_data(round_num, reasoning, code, result, feedback):
    """Construct a Round_Data dict the same way DataAnalysisAgent._handle_generate_code does."""
    def summarize_result(r):
        if r.get("success"):
            evidence_rows = r.get("evidence_rows", [])
            if evidence_rows:
                num_rows = len(evidence_rows)
                num_cols = len(evidence_rows[0]) if evidence_rows else 0
                return f"执行成功，输出 DataFrame ({num_rows}行×{num_cols}列)"
            output = r.get("output", "")
            if output:
                first_line = output.strip().split("\n")[0][:80]
                return f"执行成功: {first_line}"
            return "执行成功"
        else:
            error = r.get("error", "未知错误")
            if len(error) > 100:
                error = error[:100] + "..."
            return f"执行失败: {error}"

    return {
        "round": round_num,
        "reasoning": reasoning,
        "code": code,
        "result_summary": summarize_result(result),
        "evidence_rows": result.get("evidence_rows", []),
        "raw_log": feedback,
        "auto_exported_files": result.get("auto_exported_files", []),
        "prompt_saved_files": result.get("prompt_saved_files", []),
    }


# Regex for parsing DATA_FILE_SAVED markers (same as CodeExecutor)
_DATA_FILE_SAVED_RE = re.compile(
    r"\[DATA_FILE_SAVED\]\s*filename:\s*(.+?),\s*rows:\s*(\d+),\s*description:\s*(.+)"
)


def parse_data_file_saved_markers(stdout_text):
    """Parse [DATA_FILE_SAVED] marker lines — mirrors CodeExecutor._parse_data_file_saved_markers."""
    results = []
    for line in stdout_text.splitlines():
        m = _DATA_FILE_SAVED_RE.search(line)
        if m:
            results.append({
                "filename": m.group(1).strip(),
                "rows": int(m.group(2)),
                "description": m.group(3).strip(),
            })
    return results


# Evidence annotation regex (same as web/main.py)
_EVIDENCE_PATTERN = re.compile(r"<!--\s*evidence:round_(\d+)\s*-->")


def split_report_to_paragraphs(markdown_content):
    """Mirrors _split_report_to_paragraphs from web/main.py."""
    lines = markdown_content.split("\n")
    paragraphs = []
    current_block = []
    current_type = "text"
    para_id = 0

    def flush_block():
        nonlocal para_id, current_block, current_type
        text = "\n".join(current_block).strip()
        if text:
            paragraphs.append({
                "id": f"p-{para_id}",
                "type": current_type,
                "content": text,
            })
            para_id += 1
        current_block = []
        current_type = "text"

    in_table = False
    in_code = False

    for line in lines:
        stripped = line.strip()

        if stripped.startswith("```"):
            if in_code:
                current_block.append(line)
                flush_block()
                in_code = False
                continue
            else:
                flush_block()
                current_block.append(line)
                current_type = "code"
                in_code = True
                continue

        if in_code:
            current_block.append(line)
            continue

        if re.match(r"^#{1,6}\s", stripped):
            flush_block()
            current_block.append(line)
            current_type = "heading"
            flush_block()
            continue

        if re.match(r"^!\[.*\]\(.*\)", stripped):
            flush_block()
            current_block.append(line)
            current_type = "image"
            flush_block()
            continue

        if stripped.startswith("|"):
            if not in_table:
                flush_block()
                in_table = True
                current_type = "table"
            current_block.append(line)
            continue
        else:
            if in_table:
                flush_block()
                in_table = False

        if not stripped:
            flush_block()
            continue

        current_block.append(line)

    flush_block()
    return paragraphs


def extract_evidence_annotations(paragraphs, rounds):
    """Mirrors _extract_evidence_annotations from web/main.py, using a rounds list instead of session."""
    supporting_data = {}
    for para in paragraphs:
        content = para.get("content", "")
        match = _EVIDENCE_PATTERN.search(content)
        if match:
            round_num = int(match.group(1))
            idx = round_num - 1
            if 0 <= idx < len(rounds):
                evidence_rows = rounds[idx].get("evidence_rows", [])
                if evidence_rows:
                    supporting_data[para["id"]] = evidence_rows
    return supporting_data



# ===========================================================================
# Property 1: Round_Data Structural Completeness (Task 16.1)
# Feature: analysis-dashboard-redesign, Property 1: Round_Data structural completeness
# Validates: Requirements 1.1, 1.3, 1.4
# ===========================================================================

ROUND_DATA_REQUIRED_FIELDS = {
    "round": int,
    "reasoning": str,
    "code": str,
    "result_summary": str,
    "evidence_rows": list,
    "raw_log": str,
}


@settings(max_examples=100)
@given(
    num_rounds=st.integers(min_value=1, max_value=20),
    results=st.lists(execution_result_st, min_size=1, max_size=20),
    reasonings=st.lists(reasoning_st, min_size=1, max_size=20),
    codes=st.lists(code_st, min_size=1, max_size=20),
    feedbacks=st.lists(feedback_st, min_size=1, max_size=20),
)
def test_prop1_round_data_structural_completeness(num_rounds, results, reasonings, codes, feedbacks):
    """Round_Data objects must contain all required fields with correct types and preserve insertion order.

    **Validates: Requirements 1.1, 1.3, 1.4**
    """
    # Build a list of rounds using the same number of entries
    count = min(num_rounds, len(results), len(reasonings), len(codes), len(feedbacks))
    rounds_list = []
    for i in range(count):
        rd = build_round_data(i + 1, reasonings[i], codes[i], results[i], feedbacks[i])
        rounds_list.append(rd)

    # Verify all required fields present with correct types
    for rd in rounds_list:
        for field, expected_type in ROUND_DATA_REQUIRED_FIELDS.items():
            assert field in rd, f"Missing field: {field}"
            assert isinstance(rd[field], expected_type), (
                f"Field '{field}' expected {expected_type.__name__}, got {type(rd[field]).__name__}"
            )

    # Verify insertion order preserved
    for i in range(len(rounds_list) - 1):
        assert rounds_list[i]["round"] <= rounds_list[i + 1]["round"], (
            f"Insertion order violated: round {rounds_list[i]['round']} > {rounds_list[i + 1]['round']}"
        )


# ===========================================================================
# Property 2: Evidence Capture Bounded (Task 16.2)
# Feature: analysis-dashboard-redesign, Property 2: Evidence capture bounded
# Validates: Requirements 4.1, 4.2, 4.3
# ===========================================================================

# Strategy for generating random DataFrames with 0-10000 rows and 1-50 columns
col_name_st = st.text(
    min_size=1, max_size=10,
    alphabet=st.sampled_from("abcdefghijklmnopqrstuvwxyz_"),
).filter(lambda s: s[0] != "_")  # column names shouldn't start with _


@settings(max_examples=100)
@given(
    num_rows=st.integers(min_value=0, max_value=10000),
    num_cols=st.integers(min_value=1, max_value=50),
)
def test_prop2_evidence_capture_bounded(num_rows, num_cols):
    """Evidence capture must return at most 10 rows with keys matching DataFrame columns.

    **Validates: Requirements 4.1, 4.2, 4.3**
    """
    # Generate a DataFrame with the given dimensions
    import numpy as np
    columns = [f"col_{i}" for i in range(num_cols)]
    if num_rows == 0:
        df = pd.DataFrame(columns=columns)
    else:
        data = np.random.randint(0, 100, size=(num_rows, num_cols))
        df = pd.DataFrame(data, columns=columns)

    # Simulate the evidence capture logic: df.head(10).to_dict(orient='records')
    evidence_rows = df.head(10).to_dict(orient="records")

    # Verify length constraints
    assert len(evidence_rows) <= 10
    assert len(evidence_rows) == min(10, len(df))

    # Verify each row dict has keys matching the DataFrame's column names
    expected_keys = set(df.columns)
    for row in evidence_rows:
        assert set(row.keys()) == expected_keys


# ===========================================================================
# Property 3: Filename Deduplication (Task 16.3)
# Feature: analysis-dashboard-redesign, Property 3: Filename deduplication
# Validates: Requirements 5.3
# ===========================================================================

@settings(max_examples=100)
@given(
    num_exports=st.integers(min_value=1, max_value=20),
    var_name=st.text(min_size=1, max_size=20, alphabet="abcdefghijklmnopqrstuvwxyz_0123456789").filter(
        lambda s: s[0].isalpha()
    ),
)
def test_prop3_filename_deduplication(num_exports, var_name):
    """All generated filenames from same-name exports must be unique.

    **Validates: Requirements 5.3**
    """
    output_dir = tempfile.mkdtemp()
    generated_filenames = []

    for _ in range(num_exports):
        # Simulate _export_dataframe dedup logic
        base_filename = f"{var_name}.csv"
        filepath = os.path.join(output_dir, base_filename)

        if os.path.exists(filepath):
            suffix = 1
            while True:
                dedup_filename = f"{var_name}_{suffix}.csv"
                filepath = os.path.join(output_dir, dedup_filename)
                if not os.path.exists(filepath):
                    base_filename = dedup_filename
                    break
                suffix += 1

        # Create the file to simulate the export
        with open(filepath, "w") as f:
            f.write("dummy")

        generated_filenames.append(base_filename)

    # Verify all filenames are unique
    assert len(generated_filenames) == len(set(generated_filenames)), (
        f"Duplicate filenames found: {generated_filenames}"
    )


# ===========================================================================
# Property 4: Auto-Export Metadata Completeness (Task 16.4)
# Feature: analysis-dashboard-redesign, Property 4: Auto-export metadata completeness
# Validates: Requirements 5.4, 5.5
# ===========================================================================

@settings(max_examples=100)
@given(
    var_name=st.text(min_size=1, max_size=20, alphabet="abcdefghijklmnopqrstuvwxyz_0123456789").filter(
        lambda s: s[0].isalpha()
    ),
    num_rows=st.integers(min_value=0, max_value=1000),
    num_cols=st.integers(min_value=1, max_value=50),
)
def test_prop4_auto_export_metadata_completeness(var_name, num_rows, num_cols):
    """Auto-export metadata must contain all required fields with correct values.

    **Validates: Requirements 5.4, 5.5**
    """
    import numpy as np
    output_dir = tempfile.mkdtemp()
    columns = [f"col_{i}" for i in range(num_cols)]

    if num_rows == 0:
        df = pd.DataFrame(columns=columns)
    else:
        data = np.random.randint(0, 100, size=(num_rows, num_cols))
        df = pd.DataFrame(data, columns=columns)

    # Simulate _export_dataframe logic
    base_filename = f"{var_name}.csv"
    filepath = os.path.join(output_dir, base_filename)

    if os.path.exists(filepath):
        suffix = 1
        while True:
            dedup_filename = f"{var_name}_{suffix}.csv"
            filepath = os.path.join(output_dir, dedup_filename)
            if not os.path.exists(filepath):
                base_filename = dedup_filename
                break
            suffix += 1

    df.to_csv(filepath, index=False)
    metadata = {
        "variable_name": var_name,
        "filename": base_filename,
        "rows": len(df),
        "cols": len(df.columns),
        "columns": list(df.columns),
    }

    # Verify all required fields present
    for field in ("variable_name", "filename", "rows", "cols", "columns"):
        assert field in metadata, f"Missing field: {field}"

    # Verify values match the source DataFrame
    assert metadata["rows"] == len(df)
    assert metadata["cols"] == len(df.columns)
    assert metadata["columns"] == list(df.columns)
    assert metadata["variable_name"] == var_name



# ===========================================================================
# Property 5: DATA_FILE_SAVED Marker Parsing Round-Trip (Task 16.5)
# Feature: analysis-dashboard-redesign, Property 5: DATA_FILE_SAVED marker parsing round-trip
# Validates: Requirements 6.3
# ===========================================================================

# Strategy for filenames: alphanumeric + Chinese + underscores + hyphens, with extension
filename_base_st = st.text(
    min_size=1,
    max_size=30,
    alphabet=st.sampled_from(
        "abcdefghijklmnopqrstuvwxyz"
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "0123456789"
        "_-"
        "数据分析结果汇总报告"
    ),
).filter(lambda s: len(s.strip()) > 0 and "," not in s)

filename_ext_st = st.sampled_from([".csv", ".xlsx"])

filename_st = st.builds(lambda base, ext: base.strip() + ext, filename_base_st, filename_ext_st)

description_st = st.text(
    min_size=1,
    max_size=100,
    alphabet=st.sampled_from(
        "abcdefghijklmnopqrstuvwxyz"
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "0123456789 "
        "各类型问题聚合统计分析结果"
    ),
).filter(lambda s: len(s.strip()) > 0)


@settings(max_examples=100)
@given(
    filename=filename_st,
    rows=st.integers(min_value=1, max_value=1000000),
    description=description_st,
)
def test_prop5_data_file_saved_marker_round_trip(filename, rows, description):
    """Formatting then parsing a DATA_FILE_SAVED marker must recover original values.

    **Validates: Requirements 6.3**
    """
    # Format the marker
    marker = f"[DATA_FILE_SAVED] filename: {filename}, rows: {rows}, description: {description}"

    # Parse using the same logic as CodeExecutor
    parsed = parse_data_file_saved_markers(marker)

    assert len(parsed) == 1, f"Expected 1 parsed result, got {len(parsed)}"
    assert parsed[0]["filename"] == filename.strip()
    assert parsed[0]["rows"] == rows
    assert parsed[0]["description"] == description.strip()


# ===========================================================================
# Property 6: Data File Preview Bounded Rows (Task 16.6)
# Feature: analysis-dashboard-redesign, Property 6: Data file preview bounded rows
# Validates: Requirements 7.2
# ===========================================================================

@settings(max_examples=100)
@given(
    num_rows=st.integers(min_value=0, max_value=10000),
    num_cols=st.integers(min_value=1, max_value=50),
)
def test_prop6_data_file_preview_bounded_rows(num_rows, num_cols):
    """Preview of a CSV file must return at most 5 rows with correct column names.

    **Validates: Requirements 7.2**
    """
    import numpy as np
    columns = [f"col_{i}" for i in range(num_cols)]

    if num_rows == 0:
        df = pd.DataFrame(columns=columns)
    else:
        data = np.random.randint(0, 100, size=(num_rows, num_cols))
        df = pd.DataFrame(data, columns=columns)

    # Write to a temp CSV file
    tmp_dir = tempfile.mkdtemp()
    csv_path = os.path.join(tmp_dir, "test_data.csv")
    df.to_csv(csv_path, index=False)

    # Read back using the same logic as the preview endpoint
    preview_df = pd.read_csv(csv_path, nrows=5)

    # Verify at most 5 rows
    assert len(preview_df) <= 5
    assert len(preview_df) == min(5, num_rows)

    # Verify column names match exactly
    assert list(preview_df.columns) == columns


# ===========================================================================
# Property 7: Evidence Annotation Parsing (Task 16.7)
# Feature: analysis-dashboard-redesign, Property 7: Evidence annotation parsing
# Validates: Requirements 11.3, 11.4
# ===========================================================================

# Strategy for generating paragraphs with/without evidence annotations
annotated_paragraph_st = st.builds(
    lambda text, round_num: f"{text} <!-- evidence:round_{round_num} -->",
    st.text(min_size=1, max_size=100, alphabet="abcdefghijklmnopqrstuvwxyz .,!"),
    st.integers(min_value=1, max_value=100),
)

plain_paragraph_st = st.text(
    min_size=1,
    max_size=100,
    alphabet="abcdefghijklmnopqrstuvwxyz .,!",
).filter(lambda s: "evidence:" not in s and len(s.strip()) > 0)


@settings(max_examples=100)
@given(
    annotated=st.lists(annotated_paragraph_st, min_size=0, max_size=10),
    plain=st.lists(plain_paragraph_st, min_size=0, max_size=10),
)
def test_prop7_evidence_annotation_parsing(annotated, plain):
    """Annotated paragraphs must be correctly extracted; non-annotated must be excluded.

    **Validates: Requirements 11.3, 11.4**
    """
    assume(len(annotated) + len(plain) > 0)

    # Build markdown by interleaving annotated and plain paragraphs
    all_paragraphs = []
    for p in annotated:
        all_paragraphs.append(("annotated", p))
    for p in plain:
        all_paragraphs.append(("plain", p))

    # Build markdown content with blank lines between paragraphs
    markdown = "\n\n".join(text for _, text in all_paragraphs)

    # Parse into paragraphs
    paragraphs = split_report_to_paragraphs(markdown)

    # Build fake rounds data (up to 100 rounds, each with some evidence)
    rounds = [
        {"evidence_rows": [{"key": f"value_{i}"}]}
        for i in range(100)
    ]

    # Extract evidence annotations
    supporting_data = extract_evidence_annotations(paragraphs, rounds)

    # Verify: annotated paragraphs with valid round numbers should be in supporting_data
    for para in paragraphs:
        content = para.get("content", "")
        match = _EVIDENCE_PATTERN.search(content)
        if match:
            round_num = int(match.group(1))
            idx = round_num - 1
            if 0 <= idx < len(rounds) and rounds[idx].get("evidence_rows"):
                assert para["id"] in supporting_data, (
                    f"Annotated paragraph {para['id']} with round {round_num} not in supporting_data"
                )
        else:
            # Non-annotated paragraphs must NOT be in supporting_data
            assert para["id"] not in supporting_data, (
                f"Non-annotated paragraph {para['id']} should not be in supporting_data"
            )


# ===========================================================================
# Property 8: SessionData JSON Round-Trip (Task 16.8)
# Feature: analysis-dashboard-redesign, Property 8: SessionData JSON round-trip
# Validates: Requirements 12.4
# ===========================================================================

# Strategy for Round_Data dicts
round_data_st = st.fixed_dictionaries({
    "round": st.integers(min_value=1, max_value=100),
    "reasoning": st.text(min_size=0, max_size=200),
    "code": st.text(min_size=0, max_size=200),
    "result_summary": st.text(min_size=0, max_size=200),
    "evidence_rows": st.lists(
        st.dictionaries(
            keys=st.text(min_size=1, max_size=10, alphabet="abcdefghijklmnopqrstuvwxyz"),
            values=st.one_of(
                st.integers(min_value=-1000, max_value=1000),
                st.text(min_size=0, max_size=20),
            ),
            min_size=0,
            max_size=5,
        ),
        min_size=0,
        max_size=10,
    ),
    "raw_log": st.text(min_size=0, max_size=200),
})

# Strategy for file metadata dicts
file_metadata_st = st.fixed_dictionaries({
    "filename": st.text(min_size=1, max_size=30, alphabet="abcdefghijklmnopqrstuvwxyz0123456789_."),
    "description": st.text(min_size=0, max_size=100),
    "rows": st.integers(min_value=0, max_value=100000),
    "cols": st.integers(min_value=0, max_value=100),
    "columns": st.lists(st.text(min_size=1, max_size=10, alphabet="abcdefghijklmnopqrstuvwxyz"), max_size=10),
    "size_bytes": st.integers(min_value=0, max_value=10000000),
    "source": st.sampled_from(["auto", "prompt"]),
})


@settings(max_examples=100)
@given(
    rounds=st.lists(round_data_st, min_size=0, max_size=20),
    data_files=st.lists(file_metadata_st, min_size=0, max_size=20),
)
def test_prop8_session_data_json_round_trip(rounds, data_files):
    """Serializing rounds and data_files to JSON and back must produce equal data.

    **Validates: Requirements 12.4**
    """
    data = {
        "rounds": rounds,
        "data_files": data_files,
    }

    # Serialize using the same approach as the codebase
    serialized = json.dumps(data, default=str)
    deserialized = json.loads(serialized)

    assert deserialized["rounds"] == rounds
    assert deserialized["data_files"] == data_files