import copy
import json
import re
import tiktoken
import uuid

from curl_cffi import requests
from tclogger import logger

from constants.envs import PROXIES
from constants.headers import OPENAI_GET_HEADERS, OPENAI_POST_DATA
from constants.models import TOKEN_LIMIT_MAP, TOKEN_RESERVED

from messagers.message_outputer import OpenaiStreamOutputer
from networks.proof_worker import ProofWorker


class OpenaiRequester:
    def __init__(self):
        self.init_requests_params()

    def init_requests_params(self):
        self.api_base = "https://chat.openai.com/backend-anon"
        self.api_me = f"{self.api_base}/me"
        self.api_models = f"{self.api_base}/models"
        self.api_chat_requirements = f"{self.api_base}/sentinel/chat-requirements"
        self.api_conversation = f"{self.api_base}/conversation"
        self.uuid = str(uuid.uuid4())
        self.requests_headers = copy.deepcopy(OPENAI_GET_HEADERS)
        extra_headers = {
            "Oai-Device-Id": self.uuid,
        }
        self.requests_headers.update(extra_headers)

    def log_request(self, url, method="GET", verbose=False):
        if verbose:
            logger.note(f"> {method}:", end=" ")
            logger.mesg(f"{url}", end=" ")

    def log_response(
        self, res: requests.Response, stream=False, iter_lines=False, verbose=False
    ):
        status_code = res.status_code
        status_code_str = f"[{status_code}]"

        if status_code == 200:
            logger_func = logger.success
        else:
            logger_func = logger.warn

        logger_func(status_code_str)

        logger.enter_quiet(not verbose)

        if stream:
            if not iter_lines:
                return

            if not hasattr(self, "content_offset"):
                self.content_offset = 0

            for line in res.iter_lines():
                line = line.decode("utf-8")
                line = re.sub(r"^data:\s*", "", line)
                if re.match(r"^\[DONE\]", line):
                    logger.success("\n[Finished]")
                    break
                line = line.strip()
                if line:
                    try:
                        data = json.loads(line, strict=False)
                        message_role = data["message"]["author"]["role"]
                        message_status = data["message"]["status"]
                        if (
                            message_role == "assistant"
                            and message_status == "in_progress"
                        ):
                            content = data["message"]["content"]["parts"][0]
                            delta_content = content[self.content_offset :]
                            self.content_offset = len(content)
                            logger_func(delta_content, end="")
                    except Exception as e:
                        logger.warn(e)
        else:
            logger_func(res.json())

        logger.exit_quiet(not verbose)

    def get_models(self):
        self.log_request(self.api_models)
        res = requests.get(
            self.api_models,
            headers=self.requests_headers,
            proxies=PROXIES,
            timeout=10,
            impersonate="chrome120",
        )
        self.log_response(res)

    def auth(self):
        self.log_request(self.api_chat_requirements, method="POST")
        res = requests.post(
            self.api_chat_requirements,
            headers=self.requests_headers,
            proxies=PROXIES,
            timeout=10,
            impersonate="chrome120",
        )
        data = res.json()
        self.chat_requirements_token = data["token"]
        self.chat_requirements_seed = data["proofofwork"]["seed"]
        self.chat_requirements_difficulty = data["proofofwork"]["difficulty"]
        self.log_response(res)

    def transform_messages(self, messages: list[dict]):
        def get_role(role):
            if role in ["system", "user", "assistant"]:
                return role
            else:
                return "system"

        new_messages = [
            {
                "author": {"role": get_role(message["role"])},
                "content": {"content_type": "text", "parts": [message["content"]]},
                "metadata": {},
            }
            for message in messages
        ]
        return new_messages

    def chat_completions(self, messages: list[dict], iter_lines=False, verbose=False):
        proof_token = ProofWorker().calc_proof_token(
            self.chat_requirements_seed, self.chat_requirements_difficulty
        )
        extra_headers = {
            "Accept": "text/event-stream",
            "Openai-Sentinel-Chat-Requirements-Token": self.chat_requirements_token,
            "Openai-Sentinel-Proof-Token": proof_token,
        }
        requests_headers = copy.deepcopy(self.requests_headers)
        requests_headers.update(extra_headers)

        post_data = copy.deepcopy(OPENAI_POST_DATA)
        extra_data = {
            "messages": self.transform_messages(messages),
            "websocket_request_id": str(uuid.uuid4()),
        }
        post_data.update(extra_data)

        self.log_request(self.api_conversation, method="POST")
        s = requests.Session()
        res = s.post(
            self.api_conversation,
            headers=requests_headers,
            json=post_data,
            proxies=PROXIES,
            timeout=10,
            impersonate="chrome120",
            stream=True,
        )
        self.log_response(res, stream=True, iter_lines=iter_lines, verbose=verbose)
        return res


class OpenaiStreamer:
    def __init__(self):
        self.model = "gpt-3.5-turbo"
        self.message_outputer = OpenaiStreamOutputer(
            owned_by="openai", model="gpt-3.5-turbo"
        )
        self.tokenizer = tiktoken.get_encoding("cl100k_base")

    def count_tokens(self, messages: list[dict]):
        token_count = sum(
            len(self.tokenizer.encode(message["content"])) for message in messages
        )
        logger.note(f"Prompt Token Count: {token_count}")
        return token_count

    def check_token_limit(self, messages: list[dict]):
        token_limit = TOKEN_LIMIT_MAP[self.model]
        token_count = self.count_tokens(messages)
        token_redundancy = int(token_limit - TOKEN_RESERVED - token_count)
        if token_redundancy <= 0:
            raise ValueError(
                f"Prompt exceeded token limit: {token_count} > {token_limit}"
            )
        return True

    def chat_response(self, messages: list[dict], iter_lines=False, verbose=False):
        self.check_token_limit(messages)
        logger.enter_quiet(not verbose)
        requester = OpenaiRequester()
        requester.auth()
        logger.exit_quiet(not verbose)
        return requester.chat_completions(
            messages=messages, iter_lines=iter_lines, verbose=verbose
        )

    def chat_return_generator(self, stream_response: requests.Response, verbose=False):
        content_offset = 0
        is_finished = False

        for line in stream_response.iter_lines():
            line = line.decode("utf-8")
            line = re.sub(r"^data:\s*", "", line)
            line = line.strip()

            if not line:
                continue

            if re.match(r"^\[DONE\]", line):
                content_type = "Finished"
                delta_content = ""
                logger.success("\n[Finished]")
                is_finished = True
            else:
                content_type = "Completions"
                delta_content = ""
                try:
                    data = json.loads(line, strict=False)
                    message_role = data["message"]["author"]["role"]
                    message_status = data["message"]["status"]
                    if message_role == "assistant" and message_status == "in_progress":
                        content = data["message"]["content"]["parts"][0]
                        if not len(content):
                            continue
                        delta_content = content[content_offset:]
                        content_offset = len(content)
                        if verbose:
                            logger.success(delta_content, end="")
                    else:
                        continue
                except Exception as e:
                    logger.warn(e)

            output = self.message_outputer.output(
                content=delta_content, content_type=content_type
            )
            yield output

        if not is_finished:
            yield self.message_outputer.output(content="", content_type="Finished")

    def chat_return_dict(self, stream_response: requests.Response):
        final_output = self.message_outputer.default_data.copy()
        final_output["choices"] = [
            {
                "index": 0,
                "finish_reason": "stop",
                "message": {"role": "assistant", "content": ""},
            }
        ]
        final_content = ""
        for item in self.chat_return_generator(stream_response):
            try:
                data = json.loads(item)
                delta = data["choices"][0]["delta"]
                delta_content = delta.get("content", "")
                if delta_content:
                    final_content += delta_content
            except Exception as e:
                logger.warn(e)
        final_output["choices"][0]["message"]["content"] = final_content.strip()
        return final_output


if __name__ == "__main__":
    streamer = OpenaiStreamer()
    messages = [
        {
            "role": "system",
            "content": "You are an LLM developed by Hansimov-CORP.\nYour name is Hansimov-Copilot.",
        },
        {"role": "user", "content": "Hello, what is your role?"},
        {"role": "assistant", "content": "I am an LLM."},
        {"role": "user", "content": "What is your name?"},
    ]

    streamer.chat_response(messages=messages, iter_lines=True, verbose=True)
    # python -m networks.openai_streamer