import asyncio
import json
import logging
import netrc
import re
import threading
import time
from json.decoder import JSONDecodeError
from queue import Queue
from typing import Callable
from urllib.request import urlopen
from uuid import UUID

import requests
import search_bot
from flask import Flask, jsonify, request
from habanero import Crossref
from waitress import serve

NETRC_FILE = r"C:\Users\Activcom.pl\.netrc"

HOST_ADDRESS = "192.168.1.192"
PORT_ADDRESS = 5001
MAIN_BOT_ADDRESS = "http://192.168.1.191:5000"
SEND_RESULTS = "/conjurer"
BDSM_UUID_TEST = "96b7f85a-1142-4908-8986-62a2ea25a147"

ENCODING = "utf-8"
app = Flask(__name__)

librarian_queue = Queue()
librarian_list = []


class Librarian(object):

    def __init__(self, app, query, uuid) -> None:
        netrc_mod = netrc.netrc(NETRC_FILE)
        authTokens = netrc_mod.authenticators("crossref")
        self.cr = Crossref(mailto=authTokens[0])
        self.query = query
        self.uuid = str(uuid)
        self.limit = 3000
        self.fetched = 0
        self.hit = 0
        self.total = 0
        self.app = app
        self.logger = app.logger
        self.live_results = []
        self.search_result_from_cr = {}
        self.done = False

    async def search_crossref(self, query):
        self.app.logger.info("STARTED SEARCH")
        result = self.cr.works(query=query, limit=1000)
        self.search_result_from_cr.update(result)
        self.total = result["message"]["total-results"]
        self.fetched += len(result["message"]["items"])
        self.logger.info(self.total)
        self.logger.info(self.fetched)
        while self.total > self.fetched and self.limit > self.fetched:
            result = self.cr.works(query=query, limit=1000)
            self.search_result_from_cr.update(result)
            self.total = result["message"]["total-results"]
            self.fetched += len(result["message"]["items"])
            self.logger.info(self.total)
            self.logger.info(self.fetched)

            time.sleep(1)
        self.app.logger.info("CROSSREF DONE")
        # TODO: add to sql with UUID
        # sql row - title, doi, author, uuid, last retrieved, is_available

        with open("rr_results.json", "r+", encoding="utf-8") as data_file:
            # First we load existing data into a dict.
            try:
                file_data = json.load(data_file)
            except JSONDecodeError:
                file_data = {}
            summarized_results = []
            self.app.logger.info("REFINE: Removing all derived works from the list")
            for item in self.search_result_from_cr["message"]["items"]:
                container = "NO"
                if "container-title" in item:
                    container = "YES"
                else:
                    summarized_results.append(
                        {
                            "DOI": item["DOI"],
                            "title": item["title"] if "title" in item else None,
                            "type": item["type"] if "type" in item else None,
                            "container": container,
                        }
                    )
            result = {
                self.uuid: {
                    "total_results": self.search_result_from_cr["message"][
                        "total-results"
                    ],
                    "on_page": 1,
                    "summary": summarized_results,
                    "results": self.search_result_from_cr["message"]["items"],
                }
            }
            if file_data:
                file_data.update(result)
            else:
                file_data = result

            self.app.logger.info("REFINE: Dumping to file")
            data_file.truncate(0)
            data_file.seek(0)
            json.dump(file_data, data_file, indent=4)
            return result

    async def check_dois_in_local_db(self, doi):
        self.app.logger.info("REFINE: Running search in the backend app")
        coro = asyncio.to_thread(
            search_bot.search_for_doi, doi, self.live_results, self.app.logger
        )
        result = await coro
        return result

    async def check_if_exists_brute_force(self, page_url):
        self.app.logger.error("REFINE: Brute force search!")
        if not page_url.startswith(("http:", "https:")):
            raise ValueError("URL must start with 'http:' or 'https:'")
        # trunk-ignore(bandit/B310)
        with urlopen(page_url) as response:
            data = response.read()
            text = data.decode("utf-8")
            for line in text.splitlines():
                if re.match(
                    r".*Unfortunately, Sci-Hub doesn't have the requested document.*",
                    line,
                ):
                    return False
                if m := re.match(
                    r".*<embed type=\"application.pdf\"\s*src=\"(.*\.pdf)", line
                ):
                    direct_download_link = "https:" + str(m.group(1))
                    self.app.logger.info(direct_download_link)
                    return True
        return False

    async def check_if_exists(self, doi, brute_force=False):
        result = {}
        result = await self.check_dois_in_local_db(doi)
        if brute_force and not result:
            for item in doi:
                item_link = "https://sci-hub.se/" + item[0]
                tmp = {
                    "DOI": item["DOI"],
                    "exists": await self.check_if_exists_brute_force(item_link),
                    "data": item,
                }
                result.update(tmp)
        return result

    async def refine_query(self, unrefined_reqult, brute_force=False):
        temp = []
        refined_result = []
        for key in unrefined_reqult:
            self.logger.info("KEY:")
            self.logger.info(key)

        for item in unrefined_reqult[self.uuid]["summary"]:
            if item["container"] == "NO" and item["title"]:
                refined_result.append(item)

        for item in refined_result:
            temp.append([item["DOI"], item])

        refined_result = await self.check_if_exists(temp)
        temp = []
        for item in refined_result:
            if item["exists"]:
                temp.append(item["data"])
        refined_result = temp
        self.hit = len(refined_result)
        return refined_result

    # TODO: DOłożyć sprawdzenie czy w rafinowanym pliku już nie mamy częściowego wyniku
    async def answer_query(self):
        # TODO: DOłożyć sprawdzenie czy w rafinowanym pliku już nie mamy częściowego wyniku tutaj bo zanim w ogóle otworzymy nierafinowany
        # Search sql for UUID
        # SQL SELECT * FROM RESULTS WHERE UUID = uuid
        self.logger.info(f"Search started {self.uuid}")
        uuid_found = False
        database = None
        query = self.query
        with open("cr_results.json", "r+", encoding="utf-8") as cr_file:
            # tu logika komunikacji z SQL i cała logika związana z wyszukaniem
            # ale tymczasowo plik
            try:
                database = json.load(cr_file)
            except JSONDecodeError:
                pass

            if database:
                for item in database.keys():
                    if item in self.uuid:
                        self.result = await self.refine_query(database)
                        return self.result
                answer = await self.search_crossref(query=query)
                database.update(answer)
                cr_file.truncate(0)
                cr_file.seek(0)
                json.dump(database, cr_file)
                self.result = await self.refine_query(answer)
                return self.result
            else:
                answer = await self.search_crossref(query=query)
                database = answer
                cr_file.truncate(0)
                cr_file.seek(0)
                json.dump(database, cr_file)
                self.result = await self.refine_query(answer)
                self.app.logger.info("Refined")
                self.done = True
                return self.result


# ============================= FLASK INTERNALS===============================
def flask_debug():
    """
    The `flask_debug` function starts a Flask application in debug mode without using the reloader.
    Do not use for production for fucks sake.
    """
    # trunk-ignore(bandit/B201)
    app.run(debug=True, use_reloader=False, host=HOST_ADDRESS, port=PORT_ADDRESS)


def waitress_run():
    """
    The `waitress_run` function serves the `app` on host "0.0.0.0"
    and port 5000 using the Waitress WSGI server.
    """
    serve(app, host=HOST_ADDRESS, port=PORT_ADDRESS)


class BackgroundTaskSearch(threading.Thread):
    def run(self):
        loop = asyncio.new_event_loop()  # loop = asyncio.get_event_loop()
        loop.run_until_complete(self._run())
        loop.close()

    async def _run(self):
        while True:
            database = None
            librarian = librarian_queue.get()
            self.app.logger.info("STARTED")
            result = await librarian.answer_query()
            result = {librarian.uuid: result}
            self.app.logger.info("Saving to file")
            with open("s_results.json", "r+", encoding="utf-8") as s_file:
                try:
                    database = json.load(s_file)
                except JSONDecodeError:
                    pass
                if database:
                    database.extend(result)
                else:
                    database = result
                self.app.logger.info("DUMPING DATA")
                s_file.truncate(0)
                s_file.seek(0)
                json.dump(database, s_file)
            self.app.logger.info("FINISHED")

            self.app.logger.info(result)
            coroutine = asyncio.to_thread(
                requests.post,
                f"{MAIN_BOT_ADDRESS}{SEND_RESULTS}",
                json=result,
                timeout=360,
            )
            self.app.logger.info("SENT")
            _ = await coroutine
            self.app.logger.info("SEND CONFIRMED")
            time.sleep(1)


# ==================================SERVER ROUTES==========================================
@app.route("/query", methods=["POST"])
async def query_database():
    record = json.loads(request.data)
    app.logger.info(record)
    app.logger.info(record["query"])
    app.logger.info(record["UUID"])
    uuid = record["UUID"]
    # TODO: TESTING ONLY======================
    uuid = UUID("{12345678-1234-5678-1234-567812345678}")

    cl = Librarian(app, record["query"], uuid)
    librarian_queue.put(cl)
    librarian_list.append(cl)
    answer_data = (record["query"], record["UUID"], librarian_queue.qsize())
    return_data = (
        jsonify(isError=False, message="Success", statusCode=200, data=answer_data),
        200,
    )
    return return_data


@app.route("/get_partial_result", methods=["POST"])
async def get_partial():
    record = json.loads(request.data)
    app.logger.info(record)
    app.logger.info(record["UUID"])
    for lib in librarian_list:
        if lib.uuid == record["UUID"]:
            answer_data = lib.live_results
            break
    return_data = (
        jsonify(isError=False, message="Success", statusCode=200, data=answer_data),
        200,
    )
    return return_data


# =======================================MAIN===================================================
if __name__ == "__main__":
    logger = logging.getLogger("conjurer_musician")
    logger.setLevel(logging.DEBUG)
    threads = []
    # threads.append(threading.Thread(target=waitress_run))
    threads.append(threading.Thread(target=flask_debug))
    bgtask = BackgroundTaskSearch()
    bgtask.app = app
    threads.append(bgtask)
    i = 0
    for worker in threads:
        try:
            logger.info(f"App number: {i}")
            i += 1
            worker.start()
        except RuntimeError as e:
            logger.error("Exploded")
            print(str(e))
    for worker in threads:
        worker.join()