from typing import List

import json
import softest
import weakref

from db import db
from models import Connector, User
from models.connector import ConnectorStatus
from tests.delphi_tables.models import ExternalProjectModel, ExternalCampaignModel, TriggerConnectorModel, \
    TriggerAdAccountModel


def label_id_from_account(account_id: str) -> int:
    return {"8653387137": 1, "3029121817": 6, "5457858855": 2}[account_id]


def provider_id_from_account(account_id: str) -> int:
    return {"8653387137": 1, "3029121817": 1, "5457858855": 2}[account_id]


def objective_from_from_bid_type(type: str) -> int:
    return {
        "Maximize Conversions": 3,  # Conversions
        "Maximize Conversion Value": 3,  # Conversions
        "Maximize clicks": 10,  # Clicks
        "cpc": 10,  # Clicks
        "cpv": 17,  # Video Views
        "Target CPA": 3,  # Conversions
        "Target ROAS": 3,  # Conversions
        "cpm": 11,  # Impressions
        "Target search page location": 16,  # Traffic
        "Target Outranking Share": 10,  # Clicks
        "unknown": 10,  # Clicks
    }[type]


def campaign_types_from_from_network_type(types: (str, str)) -> List:
    mapping = {
        ("Search Network", "Search partners"): [1, 8],
        ("YouTube Search", "YouTube Search"): [1, 8],
        ("YouTube Videos", "YouTube Videos"): [1, 8],
        ("Display Network", "Display Network"): [1, 3],
    }
    return mapping.get((types[0].main, types[0].secondary), [])


class Verifier:
    def __init__(self, test_case: softest.TestCase):
        self.test_case = weakref.ref(test_case)

    def verify_project_artists(self, project_id: str, artists_ids: List[str]):
        artists_ids = sorted(artists_ids)
        result = db.session.execute(
            f"""SELECT * FROM project_artists WHERE project_id='{project_id}' ORDER BY project_artists.artist_id"""
        ).fetchall()
        views_result = db.session.execute(
            f"""SELECT * FROM project_artists_view WHERE project_id='{project_id}'
            ORDER BY project_artists_view.artist_id"""
        ).fetchall()
        print(f"DEBUG [project_artists] = {result}. Expected: {artists_ids}. Views: {views_result}")
        self.test_case().assertEqual(len(result), len(artists_ids))
        for index, item in enumerate(result):
            self.test_case().assertEqual(result[index]["artist_id"], artists_ids[index])

    def verify_project_campaigns(self, project_id: str, campaigns_ids: List[str]):
        campaigns_ids = sorted(campaigns_ids)
        result = db.session.execute(
            f"""SELECT * FROM project_campaigns WHERE project_id='{project_id}' ORDER BY campaign_id"""
        ).fetchall()
        views_result = db.session.execute(
            f"""SELECT * FROM project_campaigns_view WHERE project_id='{project_id}' ORDER BY campaign_id """
        ).fetchall()
        print(f"DEBUG [project_campaigns] = {result}. Expected: {campaigns_ids}. Views: {views_result}")
        self.test_case().assertEqual(len(result), len(campaigns_ids))
        for index, item in enumerate(sorted(result)):
            self.test_case().assertEqual(result[index]["campaign_id"], campaigns_ids[index])

    def verify_project(self, project: ExternalProjectModel):
        result = db.session.execute(
            f"""SELECT * FROM projects WHERE id='{project.prs_id or project.ccp_id}' """
        ).fetchone()
        views_result = db.session.execute(
            f"""SELECT * FROM projects WHERE id='{project.prs_id or project.ccp_id}' """
        ).fetchone()
        print(f"DEBUG [project] = {result}. Expected: {project}. Views: {views_result}")
        self.test_case().assertEqual(result["name"], project.name)
        self.test_case().assertEqual(result["budget"], project.budget)
        self.test_case().assertEqual(result["decibel_label_id"], project.label)
        # self.test_case().assertEqual(result["start_date"], project.start_date)
        self.test_case().assertEqual(result["end_date"], project.end_date)
        self.test_case().assertEqual(result["gras_id"], project.gras_id)

    def verify_project_absent(self, project_id):
        result = db.session.execute(
            f"""SELECT * FROM projects WHERE id='{project_id}' """
        ).fetchone()
        self.test_case().assertIsNone(result)

    def verify_user_project(self, project_id: str, user_ids: List[int]):
        result = db.session.execute(
            f"""
            SELECT * FROM user_projects WHERE project_id='{project_id}' ORDER BY user_id
        """
        ).fetchall()
        views_result = db.session.execute(
            f"""
            SELECT * FROM user_projects_view WHERE project_id='{project_id}' ORDER BY user_id
        """
        ).fetchall()
        print(f"DEBUG [user_project] = {result}. Expected: {user_ids}. Views: {views_result}")
        self.test_case().assertEqual(len(result), len(user_ids))
        for index, item in enumerate(sorted(result)):
            self.test_case().assertEqual(result[index]["user_id"], user_ids[index])

    def verify_campaign(self, campaign: ExternalCampaignModel):
        result = db.session.execute(f"""SELECT * FROM campaigns WHERE id = '{campaign.id}' """).fetchone()
        views_result = db.session.execute(f""" SELECT * FROM campaigns_view WHERE id='{campaign.id}' """).fetchall()
        print(f"DEBUG [campaigns] = {result}. Expected: {campaign}. Views: {views_result}")
        self.test_case().assertEqual(result["name"], campaign.name)
        self.test_case().assertEqual(float(result["budget"]), campaign.budget)
        self.test_case().assertEqual(float(result["spend"]), campaign.spend)
        self.test_case().assertEqual(result["decibel_label_id"], campaign.label)
        self.test_case().assertEqual(result["start_date"], campaign.start_date)
        self.test_case().assertEqual(result["end_date"], campaign.end_date)
        self.test_case().assertEqual(result["provider_id"], campaign.provider)
        self.test_case().assertEqual(result["objective_id"], campaign.objective)
        self.test_case().assertEqual(result["category_id"], campaign.category)
        self.test_case().assertEqual(result["sub_category_id"], campaign.subcategory)

    def verify_campaign_not_exists(self, campaign: ExternalCampaignModel):
        result = db.session.execute(f"""SELECT * FROM campaigns WHERE id = '{campaign.id}' """).fetchone()
        views_result = db.session.execute(f""" SELECT * FROM campaigns_view WHERE id='{campaign.id}' """).fetchall()
        print(f"DEBUG [campaigns] = {result}. Expected: {campaign}. Views: {views_result}")
        self.test_case().assertIsNone(result)

    def verify_connector(self, connector: TriggerConnectorModel):
        result = db.session.execute(
            f"""SELECT * FROM connectors WHERE id='{connector.id}' """
        ).fetchone()
        print(f"DEBUG [connector] = {result}. Expected: {connector}.")
        self.test_case().assertEqual(result["id"], connector.id)
        self.test_case().assertEqual(result["schema_name"], connector.schema_name)
        self.test_case().assertEqual(result["decibel_label_id"], connector.decibel_label_id)
        self.test_case().assertEqual(result["is_active"], connector.is_active)
        self.test_case().assertEqual(result["user_id"], connector.user_id)
        self.test_case().assertEqual(result["date_created"], connector.date_created)
        self.test_case().assertEqual(result["manager"], connector.manager)

    def verify_ad_account(self, ad_account: TriggerAdAccountModel):
        result = db.session.execute(
            f"""SELECT * FROM ad_accounts WHERE connector_id='{ad_account.connector_id}' AND ad_account_id='{ad_account.ad_account_id}'"""
        ).fetchone()
        print(f"DEBUG [connector] = {result}. Expected: {ad_account}.")
        self.test_case().assertEqual(result["connector_id"], ad_account.connector_id)
        self.test_case().assertEqual(result["ad_account_id"], ad_account.ad_account_id)


class Requests:
    def __init__(self, test_case: softest.TestCase):
        self.test_case = weakref.ref(test_case)

    @staticmethod
    def __map_artist(artist_id: str) -> dict:
        return {"id": artist_id, "image": None, "isSony": True, "name": "TestAtrist", "type": "Primary"}

    @staticmethod
    def __project_metadata(model: ExternalProjectModel, owner_id: int = 1) -> dict:
        targets = list(map(Requests.__map_artist, model.artists))
        return {
            "targets": {"items": targets, "type": "Artist"},
            "name": model.name,
            "endDate": model.end_date.strftime("%Y-%m-%d"),
            "startDate": model.start_date.strftime("%Y-%m-%d"),
        }

    @staticmethod
    def __campaign_metadata(model: ExternalCampaignModel) -> dict:
        return {
            "territories": [1],
            "plannedBudget": model.budget,
            "budgetSpend": model.spend,
            "campaignType": model.subcategory,
            "gratis": False,
            "platforms": [1],
            "provider": model.provider,
            "objective": model.objective,
            "audienceLowerAge": 1,
            "audienceHigherAge": 30,
            "genders": [0],
            "name": model.name,
            "endDate": model.end_date.strftime("%Y-%m-%d"),
            "startDate": model.start_date.strftime("%Y-%m-%d"),
        }

    def claim_project(self, project_id: int, model: ExternalProjectModel):
        data = Requests.__project_metadata(model)
        path = f"/unassigned-projects/{project_id}"
        self.test_case().execute_post(path, headers=self.test_case().headers, data=json.dumps(data))

    def update_project(self, project_id: int, model: ExternalProjectModel):
        data = Requests.__project_metadata(model)
        path = f"/projects/{project_id}"
        self.test_case().execute_put(path, headers=self.test_case().headers, data=json.dumps(data))

    def assign_campaign_to_project(self, project_id: int, campaign_uuid: str):
        path = f"/projects/{project_id}/manage-external-campaigns"
        body = {
            "assignCampaignsUuids": [campaign_uuid]
        }
        self.test_case().execute_post(path, headers=self.test_case().headers, data=json.dumps(body))

    def unassign_campaign_from_project(self, project_id: int, campaign_uuid: str):
        path = f"/projects/{project_id}/manage-external-campaigns"
        body = {
            "unassignCampaignsUuids": [campaign_uuid]
        }
        self.test_case().execute_post(path, headers=self.test_case().headers, data=json.dumps(body))

    def add_user_to_project_team(self, project_id: int, user_id: int):
        data = {"added": [{"userId": user_id, "roleId": 1, "categoryIds": [1, 2, 3]}]}
        path = f"/projects/{project_id}/team"
        self.test_case().execute_post(path, data=json.dumps(data), headers=self.test_case().headers)

    def remove_user_from_project_team(self, project_id: int, user_id: int):
        data = {"deleted": [{"userId": user_id, "roleId": 1, "categoryIds": []}]}
        path = f"/projects/{project_id}/team"
        self.test_case().execute_post(path, data=json.dumps(data), headers=self.test_case().headers)

    def update_user_in_project_team(self, project_id: int, user_id: int):
        data = {"updated": [{"userId": user_id, "roleId": 1, "categoryIds": [1, 2, 3]}]}
        path = f"/projects/{project_id}/team"
        self.test_case().execute_post(path, data=json.dumps(data), headers=self.test_case().headers)

    def transfer_ownership_to_user(self, project_id: int, user_id: int, model: ExternalProjectModel):
        data = Requests.__project_metadata(model, owner_id=user_id)
        path = f"/projects/{project_id}"
        self.test_case().execute_put(path, headers=self.test_case().headers, data=json.dumps(data))

    def create_campaign(self, project_id: int, model: ExternalCampaignModel):
        data = Requests.__campaign_metadata(model)
        path = f"/projects/{project_id}/campaigns"
        self.test_case().execute_post(path, headers=self.test_case().headers, data=json.dumps(data))

    def update_campaign(self, project_id: int, campaign_uuid: str, model: ExternalCampaignModel):
        data = Requests.__campaign_metadata(model)
        path = f"/projects/{project_id}/campaigns/{campaign_uuid}"
        return self.test_case().execute_put(path, headers=self.test_case().headers, data=json.dumps(data))

    def create_connector(self, connector: TriggerConnectorModel):
        conn = Connector()
        conn.external_id = connector.id
        conn.name = connector.schema_name
        conn.label_id = connector.decibel_label_id
        conn.owner_id = connector.user_id
        conn.platform = connector.platform
        conn.status = ConnectorStatus.INCOMPLETE.value

        db.session.add(conn)
        db.session.commit()

    def update_connector_status(self, external_id: str, new_status: int):
        db.session.query(Connector).filter(Connector.external_id == external_id).update({"status": new_status})
        db.session.commit()

    def delete_connector(self, external_id: str):
        db.session.query(Connector).filter(Connector.external_id == external_id).delete(synchronize_session="fetch")

    def update_manager(self, user_id: int, manager_id: int):
        db.session.query(User).filter(User.id == user_id).update({"manager_id": manager_id})
        db.session.commit()