from collections import namedtuple

import pytest
from sqlalchemy.orm import clear_mappers

from ordr3.views import RE_SIMPLE_URL

ParsedMail = namedtuple("ParsedMail", ["body", "link"])


@pytest.fixture
def _pyramid_app():
    from ordr3 import main

    config = {
        "pyramid.includes": ["pyramid_debugtoolbar", "pyramid_mailer.testing"],
        "sqlalchemy.url": "sqlite:///:memory:",
        "retry.attempts": "3",
        "auth.secret": "change me for production",
        "session.secret": "change me for production",
        "session.auto_csrf": "true",
        "static_views.cache_max_age": "0",
        "mail.host": "localhost",
        "mail.port": "2525",
        "mail.default_sender": "ordr@example.com",
        "jinja2.filters ": [
            "resource_url = pyramid_jinja2.filters:resource_url_filter",
            "as_date = ordr3.views:jinja_date",
            "as_time = ordr3.views:jinja_time",
            "as_datetime = ordr3.views:jinja_datetime",
            "view_comment = ordr3.views:jinja_view_comment",
            "extract_links = ordr3.views:jinja_extract_links",
            "nl2br = ordr3.views:jinja_nl2br",
        ],
    }

    yield main({}, **config)
    clear_mappers()


@pytest.fixture
def _sqlite_repo(_pyramid_app):
    from pyramid.scripting import prepare

    from ordr3 import adapters

    with prepare() as env:
        with env["request"].tm:
            repo = env["root"].request.repo
            adapters.metadata.create_all(repo.session.get_bind())
            yield repo


@pytest.fixture
def _example_data(_sqlite_repo):
    from datetime import datetime, timedelta

    from ordr3 import models, security

    today = datetime.utcnow()
    crypt_context = security.get_passlib_context()

    nested = _sqlite_repo.session.begin_nested()

    user = models.User(
        1,
        "TestUser",
        "Jon",
        "Smith",
        "jon@example.com",
        crypt_context.hash("jon"),
        models.UserRole.USER,
    )
    _sqlite_repo.add_user(user)

    admin = models.User(
        2,
        "TestAdmin",
        "Jane",
        "Doe",
        "jane@example.com",
        crypt_context.hash("jane"),
        models.UserRole.ADMIN,
    )
    _sqlite_repo.add_user(admin)

    inactive = models.User(
        3,
        "TestInactive",
        "Peter",
        "Peter",
        "peter@example.com",
        crypt_context.hash("peter"),
        models.UserRole.INACTIVE,
    )
    _sqlite_repo.add_user(inactive)

    order_1 = models.OrderItem(
        1,
        "Ethanol",
        "123",
        "VWR",
        models.OrderCategory.SOLVENT,
        "1 l",
        12.3,
        1,
        "EUR",
        "",
        "",
    )
    _sqlite_repo.add_order(order_1)
    log_entry = models.LogEntry(
        order_1.id,
        models.OrderStatus.COMPLETED,
        admin.username,
        today - timedelta(days=1),
    )
    order_1.add_to_log(log_entry)

    order_2 = models.OrderItem(
        2,
        "NaCl",
        "234",
        "Carl Roth",
        models.OrderCategory.CHEMICAL,
        "2 kg",
        23.4,
        2,
        "EUR",
        "Haushalt",
        "Kochsalz",
    )
    _sqlite_repo.add_order(order_2)
    log_entry = models.LogEntry(
        order_2.id,
        models.OrderStatus.APPROVAL,
        admin.username,
        today - timedelta(days=2),
    )
    order_2.add_to_log(log_entry)

    order_3 = models.OrderItem(
        3,
        "Eppis",
        "345",
        "VWR",
        models.OrderCategory.BIOLAB,
        "3 St",
        34.5,
        3,
        "USD",
        "Toto",
        "auf der Seite http://www.example.com/foo gefunden",
    )
    _sqlite_repo.add_order(order_3)
    log_entry = models.LogEntry(
        order_3.id,
        models.OrderStatus.OPEN,
        user.username,
        today - timedelta(days=3),
    )
    order_3.add_to_log(log_entry)
    log_entry = models.LogEntry(
        order_3.id,
        models.OrderStatus.COMPLETED,
        admin.username,
        today - timedelta(days=2),
    )
    order_3.add_to_log(log_entry)

    order_4 = models.OrderItem(
        4,
        "Spritzen",
        "456",
        "Sigma Aldrich",
        models.OrderCategory.BIOLAB,
        "4 St",
        4.5,
        4,
        "EUR",
        "",
        "",
    )
    _sqlite_repo.add_order(order_4)
    log_entry = models.LogEntry(
        order_4.id,
        models.OrderStatus.OPEN,
        user.username,
        today - timedelta(days=4),
    )
    order_4.add_to_log(log_entry)

    _sqlite_repo.session.add(models.Vendor("vwr", "VWR"))
    _sqlite_repo.session.add(models.Vendor("vr", "VWR"))
    _sqlite_repo.session.add(models.Vendor("vwr.de", "VWR"))
    _sqlite_repo.session.add(models.Vendor("carl roth", "Carl Roth"))
    _sqlite_repo.session.add(models.Vendor("roth", "Carl Roth"))
    _sqlite_repo.session.add(models.Vendor("cr", "Carl Roth"))
    _sqlite_repo.session.add(models.Vendor("merck", "Merck"))
    _sqlite_repo.session.add(models.Vendor("merk", "Merck"))

    nested.commit()
    _sqlite_repo.session.flush()


@pytest.fixture
def testapp(_pyramid_app, _example_data):
    from webtest import TestApp

    return TestApp(_pyramid_app)


@pytest.fixture
def login_as(testapp):
    def _do_login(username, password):
        testapp.get("/logout")
        response = testapp.get("/login")
        form = response.form
        form["username"] = username
        form["password"] = password
        return form.submit("submit")

    return _do_login


@pytest.fixture
def parse_latest_mail(testapp):
    from pyramid_mailer import get_mailer

    def _parse_mail():
        registry = testapp.app.registry
        mailer = get_mailer(registry)
        last_mail = mailer.outbox[-1]
        body = last_mail.body
        links = RE_SIMPLE_URL.findall(body)
        link = links[0] if links else None
        return ParsedMail(body, link)

    return _parse_mail


@pytest.fixture
def contains(testapp):  # noqa: ARG001
    def _contains(response, **what):
        result = [(key in response) == value for key, value in what.items()]
        return all(result)

    return _contains