import agentpy as ap
import math


class FirmAgent(ap.Agent):
    def setup(self, code, name, type_region, revenue_log, a_lst_product):
        self.firm_network = self.model.firm_network
        self.product_network = self.model.product_network

        self.code = code
        self.name = name
        self.type_region = type_region
        self.revenue_log = revenue_log
        self.a_lst_product = a_lst_product
        self.dct_prod_capacity = dict.fromkeys(self.a_lst_product)

        self.a_lst_up_product_removed = ap.AgentList(self.model, [])
        self.a_lst_product_disrupted = ap.AgentList(self.model, [])
        self.a_lst_product_removed = ap.AgentList(self.model, [])

        self.dct_n_trial_up_prod_removed = {}
        self.dct_cand_alt_supply_up_prod_removed = {}
        self.dct_request_prod_from_firm = {}

        # para
        self.flt_crit_supplier = float(self.p.crit_supplier)
        self.flt_firm_req_prf_size = float(self.p.firm_req_prf_size)
        self.is_firm_req_prf_conn = bool(self.p.firm_req_prf_conn)
        self.flt_firm_acc_prf_size = float(self.p.firm_acc_prf_size)
        self.is_firm_acc_prf_conn = bool(self.p.firm_acc_prf_conn)
        self.flt_diff_new_conn = float(self.p.diff_new_conn)

    def remove_edge_to_cus_remove_cus_up_prod(self, remove_product):
        lst_out_edge = list(
            self.firm_network.graph.out_edges(
                self.firm_network.positions[self], keys=True, data='Product'))
        for n1, n2, key, product_code in lst_out_edge:
            if product_code == remove_product.code:
                # remove edge
                self.firm_network.graph.remove_edge(n1, n2, key)

                # remove customer up product conditionally
                customer = ap.AgentIter(self.model, n2).to_list()[0]
                lst_in_edge = list(
                    self.firm_network.graph.in_edges(n2,
                                                     keys=True,
                                                     data='Product'))
                lst_select_in_edge = [
                    edge for edge in lst_in_edge
                    if edge[-1] == remove_product.code
                ]
                prod_remove = math.exp(-1 * self.flt_crit_supplier *
                                       len(lst_select_in_edge))
                if self.model.nprandom.choice([True, False],
                                              p=[prod_remove,
                                                 1 - prod_remove]):
                    # print(self.name, remove_product.code, 'affect',
                    #       customer.name)
                    if remove_product not in \
                            customer.a_lst_up_product_removed:
                        customer.a_lst_up_product_removed.append(
                            remove_product)
                        customer.dct_n_trial_up_prod_removed[
                            remove_product] = 0

    def seek_alt_supply(self):
        for product in self.a_lst_up_product_removed:
            # print(f"{self.name} seek alt supply for {product.code}")
            if self.dct_n_trial_up_prod_removed[
                    product] <= self.model.int_n_max_trial:
                if self.dct_n_trial_up_prod_removed[product] == 0:
                    # select a list of candidate firm that has the product
                    self.dct_cand_alt_supply_up_prod_removed[product] = \
                        self.model.a_lst_total_firms.select([
                            product in firm.a_lst_product
                            and product not in firm.a_lst_product_removed
                            for firm in self.model.a_lst_total_firms
                        ])
                if not self.dct_cand_alt_supply_up_prod_removed[product]:
                    continue
                # select based on connection
                lst_firm_connect = []
                if self.is_firm_req_prf_conn:
                    for firm in \
                            self.dct_cand_alt_supply_up_prod_removed[product]:
                        out_edges = self.model.firm_network.graph.out_edges(
                            self.model.firm_network.positions[firm], keys=True)
                        in_edges = self.model.firm_network.graph.in_edges(
                            self.model.firm_network.positions[firm], keys=True)
                        lst_adj_firm = []
                        lst_adj_firm += \
                            [ap.AgentIter(self.model, edge[1]).to_list()[
                                0].code for edge in out_edges]
                        lst_adj_firm += \
                            [ap.AgentIter(self.model, edge[0]).to_list()[
                                0].code for edge in in_edges]
                        if self.code in lst_adj_firm:
                            lst_firm_connect.append(firm)
                if len(lst_firm_connect) == 0:
                    # select based on size
                    lst_size_damp = \
                        [size ** self.flt_firm_req_prf_size for size in
                         self.dct_cand_alt_supply_up_prod_removed[
                             product].revenue_log]
                    lst_prob = [size_damp / sum(lst_size_damp)
                                for size_damp in lst_size_damp]
                    select_alt_supply = self.model.nprandom.choice(
                        self.dct_cand_alt_supply_up_prod_removed[product],
                        p=lst_prob)
                elif len(lst_firm_connect) > 0:
                    # select based on size of firm that has connection
                    lst_firm_size_damp = \
                        [firm.revenue_log ** self.flt_firm_acc_prf_size
                            for firm in lst_firm_connect]
                    lst_prob = \
                        [size_damp / sum(lst_firm_size_damp)
                            for size_damp in lst_firm_size_damp]
                    select_alt_supply = \
                        self.model.nprandom.choice(lst_firm_connect,
                                                   p=lst_prob)
                # print(
                #     f"{self.name} selct alt supply for {product.code} "
                #     f"from {select_alt_supply.name}"
                # )
                assert product in select_alt_supply.a_lst_product, \
                    f"{select_alt_supply} \
                        does not produce requested product {product}"

                if product in select_alt_supply.dct_request_prod_from_firm.\
                        keys():
                    select_alt_supply.dct_request_prod_from_firm[
                        product].append(self)
                else:
                    select_alt_supply.dct_request_prod_from_firm[product] = [
                        self
                    ]
                # print(
                #     select_alt_supply.name, 'dct_request_prod_from_firm', {
                #         key.code: [v.name for v in value]
                #         for key, value in
                #         select_alt_supply.dct_request_prod_from_firm.items()
                #     })

                self.dct_n_trial_up_prod_removed[product] += 1

    def handle_request(self):
        # print(self.name, 'handle_request')
        for product, lst_firm in self.dct_request_prod_from_firm.items():
            if self.dct_prod_capacity[product] > 0:
                if len(lst_firm) == 0:
                    continue
                elif len(lst_firm) == 1:
                    self.accept_request(lst_firm[0], product)
                elif len(lst_firm) > 1:
                    # handling based on connection
                    lst_firm_connect = []
                    if self.is_firm_acc_prf_conn:
                        for firm in lst_firm:
                            out_edges = \
                                self.model.firm_network.graph.out_edges(
                                    self.model.firm_network.positions[firm],
                                    keys=True)
                            in_edges = \
                                self.model.firm_network.graph.in_edges(
                                    self.model.firm_network.positions[firm],
                                    keys=True)
                            lst_adj_firm = []
                            lst_adj_firm += \
                                [ap.AgentIter(self.model, edge[1]).to_list()[
                                    0].code for edge in out_edges]
                            lst_adj_firm += \
                                [ap.AgentIter(self.model, edge[0]).to_list()[
                                    0].code for edge in in_edges]
                            if self.code in lst_adj_firm:
                                lst_firm_connect.append(firm)
                    if len(lst_firm_connect) == 0:
                        # handling based on size
                        lst_firm_size_damp = \
                            [firm.revenue_log ** self.flt_firm_acc_prf_size
                             for firm in lst_firm]
                        lst_prob = \
                            [size_damp / sum(lst_firm_size_damp)
                             for size_damp in lst_firm_size_damp]
                        select_customer = \
                            self.model.nprandom.choice(lst_firm, p=lst_prob)
                        self.accept_request(select_customer, product)
                    elif len(lst_firm_connect) > 0:
                        # handling based on size of firm that has connection
                        lst_firm_size_damp = \
                            [firm.revenue_log ** self.flt_firm_acc_prf_size
                             for firm in lst_firm_connect]
                        lst_prob = \
                            [size_damp / sum(lst_firm_size_damp)
                             for size_damp in lst_firm_size_damp]
                        select_customer = \
                            self.model.nprandom.choice(lst_firm_connect,
                                                       p=lst_prob)
                        self.accept_request(select_customer, product)

    def accept_request(self, down_firm, product):
        lst_firm_size = [
            firm.revenue_log for firm in self.model.a_lst_total_firms
            if product in firm.a_lst_product
            and product not in firm.a_lst_product_removed
        ]
        prod_accept = self.revenue_log / sum(lst_firm_size)
        # damp prod
        prod_accept = prod_accept ** self.flt_diff_new_conn
        if self.model.nprandom.choice([True, False],
                                      p=[prod_accept, 1 - prod_accept]):
            self.firm_network.graph.add_edges_from([
                (self.firm_network.positions[self],
                 self.firm_network.positions[down_firm], {
                     'Product': product.code
                })
            ])
            self.dct_prod_capacity[product] -= 1
            self.dct_request_prod_from_firm[product].remove(down_firm)
            down_firm.a_lst_up_product_removed.remove(product)
            # print(
            #     f"{self.name} accept {product.code} request "
            #     f"from {down_firm.name}"
            # )
        else:
            down_firm.dct_cand_alt_supply_up_prod_removed[product].remove(self)

    def clean_before_trial(self):
        self.dct_request_prod_from_firm = {}

    def clean_before_time_step(self):
        self.dct_n_trial_up_prod_removed = {}
        self.a_lst_up_product_removed = ap.AgentList(self.model, [])

    def get_firm_network_node(self):
        return self.firm_network.positions[self]
