import os
from collections import namedtuple

import boto3
import pymysql
import pymysql.cursors
import pytest
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
from dotenv import load_dotenv
from snowflake import connector as snowflake_connector

load_dotenv()

Config = namedtuple(
    "Config",
    ["vendor_id", "vendor_currency", "statement_period_id"],
)


@pytest.fixture(scope="session", autouse=True)
def config():
    return Config(
        vendor_id=os.environ["VENDOR_ID"],
        vendor_currency=os.environ["VENDOR_CURRENCY"],
        statement_period_id=os.environ["STATEMENT_PERIOD_ID"],
    )


@pytest.fixture(scope="session", autouse=True)
def collaborators_conn():
    yield pymysql.connect(
        host=os.environ["DB_COLLABORATORS_HOST"],
        user=os.environ["DB_COLLABORATORS_USER"],
        password=os.environ["DB_COLLABORATORS_PASSWORD"],
        database=os.environ["DB_COLLABORATORS_DB"],
        cursorclass=pymysql.cursors.DictCursor,
        autocommit=True,
    )


@pytest.fixture(scope="session", autouse=True)
def art_relations_conn():
    yield pymysql.connect(
        host=os.environ["DB_ART_RELATIONS_HOST"],
        user=os.environ["DB_ART_RELATIONS_USER"],
        password=os.environ["DB_ART_RELATIONS_PASSWORD"],
        database=os.environ["DB_ART_RELATIONS_DB"],
        cursorclass=pymysql.cursors.DictCursor,
    )


@pytest.fixture(scope="session", autouse=True)
def snowflake_conn():
    private_key = os.environ.get("SNOWFLAKE_PRIVATE_KEY")
    private_key_path = os.environ.get("SNOWFLAKE_PRIVATE_KEY_PATH")

    passphrase = os.environ.get("SNOWFLAKE_KEY_PASSPHRASE", "")
    passphrase_bytes = bytes(passphrase, "utf-8")

    if private_key_path:
        with open(private_key_path, "rb") as key:
            private_key_bytes = key.read()
    elif private_key:
        private_key_bytes = bytes(private_key, "utf-8")

    decrypted_key = serialization.load_pem_private_key(
        private_key_bytes,
        password=(passphrase_bytes or None),
        backend=default_backend(),
    )

    decrypted_key_bytes = decrypted_key.private_bytes(
        encoding=serialization.Encoding.DER,
        format=serialization.PrivateFormat.PKCS8,
        encryption_algorithm=serialization.NoEncryption(),
    )

    yield snowflake_connector.connect(
        user=os.environ["SNOWFLAKE_USER"],
        account=os.environ["SNOWFLAKE_ACCOUNT"],
        warehouse=os.environ["SNOWFLAKE_WAREHOUSE"],
        role=os.environ["SNOWFLAKE_ROLE"],
        private_key=decrypted_key_bytes,
    )


@pytest.fixture(scope="session", autouse=True)
def sqs_client():
    return boto3.client("sqs")