import logging

from behave import step
from nose.tools import assert_equal

from atlas_um import pgdb
from tests.atlas_um.factories import (
    DNAAccountFactory,
    ClaimValueFactory,
    ClaimNameFactory,
    ResourceGroupFactory,
    BusinessUnitFactory,
    PersonnelTypeFactory,
    JobCategoryFactory,
    InternalUserDomainFactory,
)

logger = logging.getLogger(__name__)


@step("there exists a DNA account")
def step_there_exists_dna_account(context):
    init_kwargs = {}
    for row in context.table:
        init_kwargs[row["field"]] = row["value"]
    dna_account = DNAAccountFactory.build(**init_kwargs)
    context.dna_account = dna_account
    internal_domain = InternalUserDomainFactory(domain="sonymusic.com")
    context.pgdb_session.add(internal_domain)
    context.pgdb_session.add(dna_account)
    context.pgdb_session.commit()


@step("there exists an expired DNA account")
def step_there_exists_expired_dna_account(context):
    init_kwargs = {}
    for row in context.table:
        init_kwargs[row["field"]] = row["value"]
    init_kwargs["expiration_date"] = context.faker.past_date()
    dna_account = DNAAccountFactory.build(**init_kwargs)
    context.dna_account = dna_account
    context.pgdb_session.add(dna_account)
    context.pgdb_session.commit()


@step("the following DNA accounts")
def step_following_dna_accounts(context):
    default_attrs = {
        "business_unit": context.extra_lookup_values["business_unit"],
        "job_category": context.extra_lookup_values["job_category"],
        "job_title": "test_job_title",
        "location": "test_location",
        "personnel_type": context.extra_lookup_values["personnel_type"],
        "preferred_username": "test_preferred_username",
        "supervisor_email": "test_supervisor_email@sme.com",
        "supervisor_name": "test_supervisor_name",
    }
    internal_domain = InternalUserDomainFactory(domain="sme.com")
    context.pgdb_session.add(internal_domain)
    for row in context.table:
        dna_attrs = dict(zip(row.headings, row.cells))
        full_name = dna_attrs.pop("name")
        names = full_name.split()
        dna_attrs["given_name"] = names[0]
        dna_attrs["family_name"] = names[1]
        dna_attrs["usm_account"] = dna_attrs["email"]
        dna_attrs.update(default_attrs)
        dna_account = DNAAccountFactory.create(**dna_attrs)
        context.pgdb_session.add(dna_account)
    context.pgdb_session.commit()
    context.extra_lookup_values["job_category"].id


@step("the following claims")
def step_following_claims(context):
    for resource_group, claim_name, claim_values, multi in context.table:
        resource_group_instance = pgdb.ResourceGroup.query.filter_by(
            name=resource_group,
        ).first()
        if resource_group_instance is None:
            resource_group_instance = ResourceGroupFactory.build(
                name=resource_group,
                external_id=resource_group.replace(" ", "").lower(),
                namespace_url=resource_group.replace(" ", "").lower(),
            )
            context.pgdb_session.add(resource_group_instance)
            context.pgdb_session.commit()

        claim_name_instance = pgdb.ClaimName.query.filter_by(
            friendly=resource_group,
        ).first()
        if claim_name_instance is None:
            serializer = "ListAppend" if multi == "Yes" else "BooleanAnd"
            claim_name_instance = ClaimNameFactory.build(
                friendly=claim_name,
                claim_values_serializer=serializer,
                resource_group=resource_group_instance,
                external_id=claim_name.replace(" ", "").lower(),
                path=claim_name.replace(" ", "").lower(),
            )
            context.pgdb_session.add(claim_name_instance)
            context.pgdb_session.commit()

        for claim_value in claim_values.split(", "):
            claim_value_instance = ClaimValueFactory.build(
                friendly=claim_value,
                claim_name=claim_name_instance,
                external_id=claim_value.replace(" ", "").lower(),
                components={},
            )
            context.pgdb_session.add(claim_value_instance)
            context.pgdb_session.commit()


@step("the following global claims")
def step_following_global_claims(context):
    for claim_name, claim_values, multi in context.table:
        claim_name_instance = pgdb.ClaimName.query.filter_by(
            friendly=claim_name,
        ).first()
        if claim_name_instance is None:
            serializer = "ListAppend" if multi == "Yes" else "BooleanAnd"
            claim_name_instance = ClaimNameFactory.build(
                friendly=claim_name,
                claim_values_serializer=serializer,
                resource_group=None,
                external_id=claim_name.replace(" ", "").lower(),
                path=claim_name.replace(" ", "").lower(),
            )
            context.pgdb_session.add(claim_name_instance)
            context.pgdb_session.commit()

        for claim_value in claim_values.split(", "):
            claim_value_instance = ClaimValueFactory.build(
                friendly=claim_value,
                claim_name=claim_name_instance,
                external_id=claim_value.replace(" ", "").lower(),
                components={},
            )
            context.pgdb_session.add(claim_value_instance)
            context.pgdb_session.commit()


@step('the following assigned claim values for DNA sub "{dna_sub}"')
def step_the_following_assigned_claim_values(context, dna_sub):
    dna_account = pgdb.DNAAccount.query.filter_by(sub=dna_sub).first()
    for claim_name, claim_values in context.table:
        dna_account.claim_values.extend(
            pgdb.ClaimValue.query.join(pgdb.ClaimName)
            .filter(
                pgdb.ClaimName.friendly == claim_name,
                pgdb.ClaimValue.friendly.in_(claim_values.split(", ")),
            )
            .all()
        )
    context.pgdb_session.commit()


@step("DNA account data should match the following")
def account_data_should_match(context):
    dna_account = pgdb.DNAAccount.query.first()
    for row in context.table:
        assert_equal(getattr(dna_account, row["field"]), row["value"])


@step("the following Business Units")
def the_following_business_units(context):
    for name, is_active in context.table:
        is_deleted = is_active != "Yes"
        obj = BusinessUnitFactory.build(name=name, is_deleted=is_deleted)
        context.pgdb_session.add(obj)
    context.pgdb_session.commit()


@step("the following Job Categories")
def the_following_job_categories(context):
    for name, is_active in context.table:
        is_deleted = is_active != "Yes"
        obj = JobCategoryFactory.build(name=name, is_deleted=is_deleted)
        context.pgdb_session.add(obj)
    context.pgdb_session.commit()


@step("the following Personnel Types")
def the_following_personnel_types(context):
    for name, is_active in context.table:
        is_deleted = is_active != "Yes"
        obj = PersonnelTypeFactory.build(name=name, is_deleted=is_deleted)
        context.pgdb_session.add(obj)
    context.pgdb_session.commit()