from abc import ABC

from core.lib import db, notify

# from core.lib.money import money
from core.util import logs

log = logs.get_logger("aggregator")


class AggregatorClient(ABC):
    def store_account_info(self, account_infos):
        # account_infos = {
        #     bank: accounts
        #     for bank, accounts in account_info.items()
        #     for account in accounts
        #     #if account["account_id"] in self.banks
        # }
        # For each bank
        for bank, accounts in account_infos.items():
            # Iterate the accounts
            for index, account in enumerate(list(accounts)):
                if "account_number" not in account:
                    account_infos[bank][index]["account_number"] = {}
                    fields = ["sort_code", "number", "iban"]
                    for field in fields:
                        if field in account:
                            account_infos[bank][index]["account_number"][
                                field
                            ] = account[field]
                            del account_infos[bank][index][field]
                    # if len(account["account_number"]) == 1:
                    #     account_infos[bank].remove(account)
        currencies = [
            account["currency"]
            for bank, accounts in account_infos.items()
            for account in accounts
        ]
        for bank, accounts in account_infos.items():
            if not self.instance.account_info:
                self.instance.account_info = {}
            self.instance.account_info[bank] = []
            for account in accounts:
                self.instance.account_info[bank].append(account)
        # self.account_info = account_infos
        self.currencies = currencies

        self.instance.currencies = currencies
        self.instance.save()

    async def process_transactions(self, account_id, transactions):
        if not transactions:
            return False
        transaction_ids = [x["transaction_id"] for x in transactions]
        new_key_name = f"new.transactions.{self.instance.id}.{self.name}.{account_id}"
        old_key_name = f"transactions.{self.instance.id}.{self.name}.{account_id}"
        # for transaction_id in transaction_ids:
        if not transaction_ids:
            return
        db.r.sadd(new_key_name, *transaction_ids)

        difference = list(db.r.sdiff(new_key_name, old_key_name))

        difference = db.convert(difference)

        new_transactions = [
            x for x in transactions if x["transaction_id"] in difference
        ]

        # Rename the new key to the old key so we can run the diff again
        db.r.rename(new_key_name, old_key_name)
        for transaction in new_transactions:
            transaction["subclass"] = self.name
            # self.tx.transaction(transaction)

    def valid_transaction(self, data):
        """
        Determine if a given transaction object is valid.
        :param data: a transaction cast
        :type data: dict
        :return: whether the transaction is valid
        :rtype: bool
        """
        txid = data["transaction_id"]
        if "amount" not in data:
            return False
        if "currency" not in data:
            return False
        amount = data["amount"]
        if amount <= 0:
            log.info(f"Ignoring transaction with negative/zero amount: {txid}")
            return False
        return True

    def extract_reference(self, data):
        """
        Extract a reference from the transaction cast.
        :param data: a transaction cast
        :type data: dict
        :return: the extracted reference or not_set
        :rtype: str
        """
        if "reference" in data:
            return data["reference"]
        elif "meta" in data:
            if "provider_reference" in data["meta"]:
                return data["meta"]["provider_reference"]
        return "not_set"

    def extract_sender(self, data):
        """
        Extract a sender name from the transaction cast.
        :param data: a transaction cast
        :type data: dict
        :return: the sender name or not_set
        :rtype: str
        """
        if "debtorName" in data:
            return data["debtorName"]
        elif "meta" in data:
            if "debtor_account_name" in data["meta"]:
                return data["meta"]["debtor_account_name"]
        elif "  " in data["reference"]:
            refsplit = data["reference"].split("  ")
            if not len(refsplit) == 2:
                log.error(f"Sender cannot be extracted: {data}")
                return "not_set"
            realname, part2 = data["reference"].split("  ")
            return realname

        return "not_set"

    async def reference_partial_check(self, reference, txid, currency, amount):
        """
        Perform a partial check by intersecting all parts of the split of the
        reference against the existing references, and returning a set of the matches.
        :param reference: the reference to check
        :type reference: str
        :return: matching trade ID string
        :rtype: str
        """
        # Partial reference implementation
        # Account for silly people not removing the default string
        # Split the reference into parts
        ref_split = reference.split(" ")
        # Get all existing references
        existing_refs = await db.get_refs()
        # Get all parts of the given reference split that match the existing references
        stored_trade_reference = set(existing_refs).intersection(set(ref_split))
        if len(stored_trade_reference) > 1:
            message = (
                f"Multiple references valid for TXID {txid}: {reference}"
                f"Currency: {currency} | Amount: {amount}"
            )
            title = "Error: multiple references valid"
            await notify.sendmsg(self.instance.user, message, title=title)
            return False
        if len(stored_trade_reference) == 0:
            return None
        return stored_trade_reference.pop()

    async def can_alt_lookup(self, amount, currency, reference):
        amount_usd = self.money.to_usd(amount, currency)
        # Amount is reliable here as it is checked by find_trade,
        # so no need for stored_trade["amount"]
        if float(amount_usd) > float(settings.Agora.AcceptableAltLookupUSD):
            message = (
                f"Amount exceeds max for {reference}"
                f"Currency: {currency} | Amount: {amount}"
            )
            title = "Amount exceeds max for {reference}"
            await notify.sendmsg(self.instance.user, message, title=title)
            return False
        return True

    async def amount_currency_lookup(self, amount, currency, txid, reference):
        log.info(f"No reference in DB refs for {reference}")
        self.irc.sendmsg(f"No reference in DB refs for {reference}")
        # Try checking just amount and currency, as some people
        # (usually people buying small amounts)
        #  are unable to put in a reference properly.

        log.info(f"Checking against amount and currency for TXID {txid}")
        self.irc.sendmsg(f"Checking against amount and currency for TXID {txid}")
        title = f"Checking against amount and currency for TXID {txid}"
        message = (
            f"Checking against amount and currency for TXID {txid}"
            f"Currency: {currency} | Amount: {amount}"
        )
        await notify.sendmsg(self.instance.user, message, title=title)
        if not await self.can_alt_lookup(amount, currency, reference):
            return False
        stored_trade = await self.find_trade(txid, currency, amount)
        if not stored_trade:
            title = f"Failed to get reference by amount and currency: {txid}"
            message = (
                f"Failed to get reference by amount and currency: {txid}"
                f"Currency: {currency} | Amount: {amount}"
            )
            await notify.sendmsg(self.instance.user, message, title=title)
            return None
        stored_trade["amount"] = float(stored_trade["amount"])  # convert to float
        return stored_trade

    async def normal_lookup(self, stored_trade_reference, reference, currency, amount):
        stored_trade = await db.get_ref(stored_trade_reference)
        if not stored_trade:
            title = f"No reference in DB for {reference}"
            message = (
                f"No reference in DB for {reference}"
                f"Currency: {currency} | Amount: {amount}"
            )
            await notify.sendmsg(self.instance.user, message, title=title)
            return False
        stored_trade["amount"] = float(stored_trade["amount"])  # convert to float
        return stored_trade

    async def currency_check(self, currency, amount, reference, stored_trade):
        if not stored_trade["currency"] == currency:
            title = "Currency mismatch"
            message = (
                f"Currency mismatch, Agora: {stored_trade['currency']} "
                f"/ Sink: {currency}"
            )
            await notify.sendmsg(self.instance.user, message, title=title)
            return False
        return True

    async def alt_amount_check(
        self, platform, amount, currency, reference, stored_trade
    ):
        # If the amount does not match exactly, get the min and max values for our
        # given acceptable margins for trades
        min_amount, max_amount = await self.money.get_acceptable_margins(
            platform, currency, stored_trade["amount"]
        )
        log.info(
            (
                f"Amount does not match exactly, trying with margins: min: {min_amount}"
                f" / max: {max_amount}"
            )
        )
        self.irc.sendmsg()
        title = "Amount does not match exactly"
        message = (
            f"Amount does not match exactly, trying with margins: min: "
            f"{min_amount} / max: {max_amount}"
        )
        await notify.sendmsg(self.instance.user, message, title=title)
        if not min_amount < amount < max_amount:
            title = "Amount mismatch - not in margins"
            message = (
                f"Amount mismatch - not in margins: {stored_trade['amount']} "
                f"(min: {min_amount} / max: {max_amount}"
            )
            await notify.sendmsg(self.instance.user, message, title=title)
            return False
        return True

    async def transaction(self, data):
        """
        Store details of transaction and post notifications to IRC.
        Matches it up with data stored in Redis to attempt to reconcile with an Agora
        trade.
        :param data: details of transaction
        :type data: dict
        """
        valid = self.valid_transaction(data)
        if not valid:
            return False
        ts = data["timestamp"]
        txid = data["transaction_id"]
        amount = float(data["amount"])
        currency = data["currency"]

        reference = self.extract_reference(data)
        sender = self.extract_sender(data)

        subclass = data["subclass"]
        to_store = {
            "subclass": subclass,
            "ts": ts,
            "txid": txid,
            "reference": reference,
            "amount": amount,
            "currency": currency,
            "sender": sender,
        }
        db.r.hmset(f"tx.{txid}", to_store)

        log.info(f"Transaction processed: {dumps(to_store, indent=2)}")
        self.irc.sendmsg(
            (
                f"AUTO Incoming transaction on {subclass}: {txid} {amount}{currency} "
                f"({reference})"
            )
        )

        stored_trade_reference = self.reference_partial_check(
            reference, txid, currency, amount
        )
        if stored_trade_reference is False:  # can be None though
            return

        stored_trade = False
        looked_up_without_reference = False

        # Normal implementation for when we have a reference
        if stored_trade_reference:
            stored_trade = self.normal_lookup(
                stored_trade_reference, reference, currency, amount
            )
            # if not stored_trade:
            #    return

        # Amount/currency lookup implementation for when we have no reference
        else:
            if not stored_trade:  # check we don't overwrite the lookup above
                stored_trade = self.amount_currency_lookup(
                    amount, currency, txid, reference
                )
                if stored_trade is False:
                    return
                if stored_trade:
                    # Note that we have looked it up without reference so we don't use
                    # +- below
                    # This might be redundant given the amount checks in find_trade,
                    # but better safe than sorry!
                    looked_up_without_reference = True
                else:
                    return
            else:
                # Stored trade reference is none, the checks below will do nothing
                return

        # Make sure it was sent in the expected currency
        if not self.currency_check(currency, amount, reference, stored_trade):
            return

        # Make sure the expected amount was sent
        if not stored_trade["amount"] == amount:
            if looked_up_without_reference:
                return
            platform = stored_trade["subclass"]
            if not self.alt_amount_check(
                platform, amount, currency, reference, stored_trade
            ):
                return
        platform = stored_trade["subclass"]
        platform_buyer = stored_trade["buyer"]

        # Check sender - we don't do anything with this yet
        # sender_valid = self.antifraud.check_valid_sender(
        #     reference, platform, sender, platform_buyer
        # )
        # log.info(f"Trade {reference} buyer {platform_buyer} valid: {sender_valid}")
        # trade_released = self.release_map_trade(reference, txid)
        # if trade_released:
        #    self.ux.notify.notify_complete_trade(amount, currency)
        # else:
        #    log.error(f"Cannot release trade {reference}.")
        #    return

        rtrn = await self.release_funds(stored_trade["id"], stored_trade["reference"])
        if rtrn:
            title = "Trade complete"
            message = f"Trade complete: {amount}{currency}"
            await notify.sendmsg(self.instance.user, message, title=title)