"""Unit tests for detect_errors lambda."""
import src.index as index


def test_handler_no_errors_returns_clean_context(sm_context):
    """All tracks succeeded — errors key absent, track_errors stripped."""
    event = {**sm_context, 'track_errors': [None, None, None]}

    result = index.handler(event, None)

    assert 'errors' not in result
    assert 'track_errors' not in result


def test_handler_preserves_context_fields(sm_context):
    """Context fields are preserved unchanged in the output."""
    event = {**sm_context, 'track_errors': [None, None, None]}

    result = index.handler(event, None)

    assert result['correlation_id'] == sm_context['correlation_id']
    assert result['grps_ingestion_id'] == sm_context['grps_ingestion_id']
    assert result['product'] == sm_context['product']
    assert result['tracks'] == sm_context['tracks']
    assert result['label_participants'] == sm_context['label_participants']


def test_handler_one_track_failed(sm_context, track_error):
    """One track failed — errors list contains that one error."""
    event = {**sm_context, 'track_errors': [None, track_error, None]}

    result = index.handler(event, None)

    assert result['errors'] == [track_error]
    assert 'track_errors' not in result


def test_handler_all_tracks_failed(sm_context, track_error):
    """All tracks failed — errors list has one entry per track."""
    event = {**sm_context, 'track_errors': [
        track_error, track_error, track_error
    ]}

    result = index.handler(event, None)

    assert len(result['errors']) == 3
    assert 'track_errors' not in result


def test_handler_upstream_error_no_track_errors(sm_context, upstream_error):
    """Upstream step failed, all tracks ok — errors contains upstream error."""
    event = {**sm_context, 'errors': upstream_error,
             'track_errors': [None, None, None]}

    result = index.handler(event, None)

    assert result['errors'] == [upstream_error]
    assert 'track_errors' not in result


def test_handler_upstream_and_track_errors(
        sm_context, upstream_error, track_error):
    """Upstream + one track failed — both errors collected in order."""
    event = {**sm_context, 'errors': upstream_error,
             'track_errors': [None, track_error, None]}

    result = index.handler(event, None)

    assert len(result['errors']) == 2
    assert result['errors'][0] == upstream_error
    assert result['errors'][1] == track_error
    assert 'track_errors' not in result


def test_handler_no_track_errors_key(sm_context):
    """track_errors key absent entirely — no errors, no KeyError."""
    result = index.handler({**sm_context}, None)

    assert 'errors' not in result
    assert 'track_errors' not in result


def test_handler_track_errors_empty_list(sm_context):
    """Empty track_errors list — no errors."""
    event = {**sm_context, 'track_errors': []}

    result = index.handler(event, None)

    assert 'errors' not in result
    assert 'track_errors' not in result


def test_handler_strips_track_errors_on_success(sm_context):
    """track_errors must never appear in the output regardless of errors."""
    event = {**sm_context, 'track_errors': [None]}

    result = index.handler(event, None)

    assert 'track_errors' not in result


def test_handler_error_dict_preserved_as_is(sm_context, track_error):
    """Error dicts are not modified — Error and Cause keys intact."""
    event = {**sm_context, 'track_errors': [track_error, None, None]}

    result = index.handler(event, None)

    assert result['errors'][0]['Error'] == track_error['Error']
    assert result['errors'][0]['Cause'] == track_error['Cause']