import logging
import uuid
import random
import threading
from fe.access import book
from fe.access.new_seller import register_new_seller
from fe.access.new_buyer import register_new_buyer
from fe.access.buyer import Buyer
from fe import conf


class NewOrder:
    def __init__(self, buyer: Buyer, store_id, book_id_and_count):
        self.buyer = buyer
        self.store_id = store_id
        self.book_id_and_count = book_id_and_count

    def run(self) -> (bool, str):
        code, order_id = self.buyer.new_order(self.store_id, self.book_id_and_count)
        return code == 200, order_id


class Payment:
    def __init__(self, buyer: Buyer, order_id):
        self.buyer = buyer
        self.order_id = order_id

    def run(self) -> bool:
        code = self.buyer.payment(self.order_id)
        return code == 200


class Workload:
    def __init__(self):
        self.uuid = str(uuid.uuid1())
        self.book_ids = []
        self.buyer_ids = []
        self.store_ids = []
        self.book_db = book.BookDB(conf.Use_Large_DB)
        self.row_count = self.book_db.get_book_count()

        self.book_num_per_store = conf.Book_Num_Per_Store
        if self.row_count < self.book_num_per_store:
            self.book_num_per_store = self.row_count
        self.store_num_per_user = conf.Store_Num_Per_User
        self.seller_num = conf.Seller_Num
        self.buyer_num = conf.Buyer_Num
        self.session = conf.Session
        self.stock_level = conf.Default_Stock_Level
        self.user_funds = conf.Default_User_Funds
        self.batch_size = conf.Data_Batch_Size
        self.procedure_per_session = conf.Request_Per_Session

        self.n_new_order = 0
        self.n_payment = 0
        self.n_new_order_ok = 0
        self.n_payment_ok = 0
        self.time_new_order = 0
        self.time_payment = 0
        self.lock = threading.Lock()
        # 存储上一次的值，用于两次做差
        self.n_new_order_past = 0
        self.n_payment_past = 0
        self.n_new_order_ok_past = 0
        self.n_payment_ok_past = 0

    def to_seller_id_and_password(self, no: int) -> (str, str):
        return "seller_{}_{}".format(no, self.uuid), "password_seller_{}_{}".format(
            no, self.uuid
        )

    def to_buyer_id_and_password(self, no: int) -> (str, str):
        return "buyer_{}_{}".format(no, self.uuid), "buyer_seller_{}_{}".format(
            no, self.uuid
        )

    def to_store_id(self, seller_no: int, i):
        return "store_s_{}_{}_{}".format(seller_no, i, self.uuid)

    def gen_database(self):
        logging.info("load data")
        for i in range(1, self.seller_num + 1):
            user_id, password = self.to_seller_id_and_password(i)
            seller = register_new_seller(user_id, password)
            for j in range(1, self.store_num_per_user + 1):
                store_id = self.to_store_id(i, j)
                code = seller.create_store(store_id)
                assert code == 200, f"create store error: {code}"
                self.store_ids.append(store_id)
                row_no = 0

                while row_no < self.book_num_per_store:
                    books = self.book_db.get_book_info(row_no, self.batch_size)
                    if len(books) == 0:
                        break
                    for bk in books:
                        code = seller.add_book(store_id, self.stock_level, bk)
                        assert code == 200, f"add book error: {code}"
                        if i == 1 and j == 1:
                            self.book_ids.append(bk.id)
                    row_no = row_no + len(books)
        logging.info("seller data loaded.")
        for k in range(1, self.buyer_num + 1):
            user_id, password = self.to_buyer_id_and_password(k)
            buyer = register_new_buyer(user_id, password)
            buyer.add_funds(self.user_funds)
            self.buyer_ids.append(user_id)
        logging.info("buyer data loaded.")

    def get_new_order(self) -> NewOrder:
        n = random.randint(1, self.buyer_num)
        buyer_id, buyer_password = self.to_buyer_id_and_password(n)
        store_no = int(random.uniform(0, len(self.store_ids) - 1))
        store_id = self.store_ids[store_no]
        books = random.randint(1, 10)
        book_id_and_count = []
        book_temp = []
        for i in range(0, books):
            book_no = int(random.uniform(0, len(self.book_ids) - 1))
            book_id = self.book_ids[book_no]
            if book_id in book_temp:
                continue
            else:
                book_temp.append(book_id)
                count = random.randint(1, 10)
                book_id_and_count.append((book_id, count))
        b = Buyer(url_prefix=conf.URL, user_id=buyer_id, password=buyer_password)
        new_ord = NewOrder(b, store_id, book_id_and_count)
        return new_ord

    def update_stat(
        self,
        n_new_order,
        n_payment,
        n_new_order_ok,
        n_payment_ok,
        time_new_order,
        time_payment,
    ):
        # 获取当前并发数
        thread_num = len(threading.enumerate())
        # 加索
        self.lock.acquire()
        self.n_new_order = self.n_new_order + n_new_order
        self.n_payment = self.n_payment + n_payment
        self.n_new_order_ok = self.n_new_order_ok + n_new_order_ok
        self.n_payment_ok = self.n_payment_ok + n_payment_ok
        self.time_new_order = self.time_new_order + time_new_order
        self.time_payment = self.time_payment + time_payment
        # 计算这段时间内新创建订单的总数目
        n_new_order_diff = self.n_new_order - self.n_new_order_past
        # 计算这段时间内新付款订单的总数目
        n_payment_diff = self.n_payment - self.n_payment_past

        if (
            self.n_payment != 0
            and self.n_new_order != 0
            and (self.time_payment + self.time_new_order)
        ):
            # TPS_C(吞吐量):成功创建订单数量/(提交订单时间/提交订单并发数 + 提交付款订单时间/提交付款订单并发数)
            # NO=OK:新创建订单数量
            # Thread_num:以新提交订单的数量作为并发数(这一次的TOTAL-上一次的TOTAL)
            # TOTAL:总提交订单数量
            # LATENCY:提交订单时间/处理订单笔数(只考虑该线程延迟，未考虑并发)
            # P=OK:新创建付款订单数量
            # Thread_num:以新提交付款订单的数量作为并发数(这一次的TOTAL-上一次的TOTAL)
            # TOTAL:总付款提交订单数量
            # LATENCY:提交付款订单时间/处理付款订单笔数(只考虑该线程延迟，未考虑并发)
            logging.info(
                "TPS_C={}, NO=OK:{} Thread_num:{} TOTAL:{} LATENCY:{} , P=OK:{} Thread_num:{} TOTAL:{} LATENCY:{}".format(
                    int(
                        self.n_new_order_ok
                        / (
                            self.time_payment / n_payment_diff
                            + self.time_new_order / n_new_order_diff
                        )
                    ),  # 吞吐量:完成订单数/((付款所用时间+订单所用时间)/并发数)
                    self.n_new_order_ok,
                    n_new_order_diff,
                    self.n_new_order,
                    self.time_new_order
                    / self.n_new_order,  # 订单延迟:(创建订单所用时间/并发数)/新创建订单数
                    self.n_payment_ok,
                    n_payment_diff,
                    self.n_payment,
                    self.time_payment / self.n_payment,  # 付款延迟:(付款所用时间/并发数)/付款订单数
                )
            )
        self.lock.release()
        # 旧值更新为新值，便于下一轮计算
        self.n_new_order_past = self.n_new_order
        self.n_payment_past = self.n_payment
        self.n_new_order_ok_past = self.n_new_order_ok
        self.n_payment_ok_past = self.n_payment_ok
