# encoding: utf-8

"""
Step implementations for paragraph-related features
"""

from behave import given, then, when

from docx import Document
from docx.enum.text import WD_TAB_ALIGNMENT, WD_TAB_LEADER
from docx.shared import Inches
from docx.text.tabstops import TabStop

from helpers import test_docx


# given ===================================================

@given('a tab_stops having {count} tab stops')
def given_a_tab_stops_having_count_tab_stops(context, count):
    paragraph_idx = {'0': 0, '3': 1}[count]
    document = Document(test_docx('tab-stops'))
    paragraph_format = document.paragraphs[paragraph_idx].paragraph_format
    context.tab_stops = paragraph_format.tab_stops


@given('a tab stop 0.5 inches {in_or_out} from the paragraph left edge')
def given_a_tab_stop_inches_from_paragraph_left_edge(context, in_or_out):
    tab_idx = {'out': 0, 'in': 1}[in_or_out]
    document = Document(test_docx('tab-stops'))
    paragraph_format = document.paragraphs[2].paragraph_format
    context.tab_stops = paragraph_format.tab_stops
    context.tab_stop = paragraph_format.tab_stops[tab_idx]


@given('a tab stop having {alignment} alignment')
def given_a_tab_stop_having_alignment_alignment(context, alignment):
    tab_idx = {'LEFT': 0, 'CENTER': 1, 'RIGHT': 2}[alignment]
    document = Document(test_docx('tab-stops'))
    paragraph_format = document.paragraphs[1].paragraph_format
    context.tab_stop = paragraph_format.tab_stops[tab_idx]


@given('a tab stop having {leader} leader')
def given_a_tab_stop_having_leader_leader(context, leader):
    tab_idx = {'no specified': 0, 'a dotted': 2}[leader]
    document = Document(test_docx('tab-stops'))
    paragraph_format = document.paragraphs[1].paragraph_format
    context.tab_stop = paragraph_format.tab_stops[tab_idx]


# when ====================================================

@when('I add a tab stop')
def when_I_add_a_tab_stop(context):
    tab_stops = context.tab_stops
    tab_stops.add_tab_stop(Inches(1.75))


@when('I assign {member} to tab_stop.alignment')
def when_I_assign_member_to_tab_stop_alignment(context, member):
    value = getattr(WD_TAB_ALIGNMENT, member)
    context.tab_stop.alignment = value


@when('I assign {member} to tab_stop.leader')
def when_I_assign_member_to_tab_stop_leader(context, member):
    value = getattr(WD_TAB_LEADER, member)
    context.tab_stop.leader = value


@when('I assign {value} to tab_stop.position')
def when_I_assign_value_to_tab_stop_value(context, value):
    context.tab_stop.position = int(value)


@when('I call tab_stops.clear_all()')
def when_I_call_tab_stops_clear_all(context):
    tab_stops = context.tab_stops
    tab_stops.clear_all()


@when('I remove a tab stop')
def when_I_remove_a_tab_stop(context):
    tab_stops = context.tab_stops
    del tab_stops[1]


# then =====================================================

@then('I can access a tab stop by index')
def then_I_can_access_a_tab_stop_by_index(context):
    tab_stops = context.tab_stops
    for idx in range(3):
        tab_stop = tab_stops[idx]
        assert isinstance(tab_stop, TabStop)


@then('I can iterate the TabStops object')
def then_I_can_iterate_the_TabStops_object(context):
    items = [ts for ts in context.tab_stops]
    assert len(items) == 3
    assert all(isinstance(item, TabStop) for item in items)


@then('len(tab_stops) is {count}')
def then_len_tab_stops_is_count(context, count):
    tab_stops = context.tab_stops
    assert len(tab_stops) == int(count)


@then('tab_stop.alignment is {alignment}')
def then_tab_stop_alignment_is_alignment(context, alignment):
    expected_value = getattr(WD_TAB_ALIGNMENT, alignment)
    tab_stop = context.tab_stop
    assert tab_stop.alignment == expected_value


@then('tab_stop.leader is {leader}')
def then_tab_stop_leader_is_leader(context, leader):
    expected_value = getattr(WD_TAB_LEADER, leader)
    tab_stop = context.tab_stop
    assert tab_stop.leader == expected_value


@then('tab_stop.position is {position}')
def then_tab_stop_position_is_position(context, position):
    tab_stop = context.tab_stop
    assert tab_stop.position == int(position)


@then('the removed tab stop is no longer present in tab_stops')
def then_the_removed_tab_stop_is_no_longer_present_in_tab_stops(context):
    tab_stops = context.tab_stops
    assert tab_stops[0].position == Inches(1)
    assert tab_stops[1].position == Inches(3)


@then('the tab stops are sequenced in position order')
def then_the_tab_stops_are_sequenced_in_position_order(context):
    tab_stops = context.tab_stops
    for idx in range(len(tab_stops) - 1):
        assert tab_stops[idx].position < tab_stops[idx+1].position