import os
from slack_bolt import App
from slack_bolt.adapter.socket_mode import SocketModeHandler
from extractcontent3 import ExtractContent
import requests
import re
from bs4 import BeautifulSoup
import openai
import tiktoken
from tiktoken.core import Encoding
from notion_client import Client
from slack_sdk import WebClient
import traceback
import json
from dotenv import load_dotenv

load_dotenv()
SLACK_APP_TOKEN = os.environ["SLACK_APP_TOKEN"]
SLACK_BOT_TOKEN = os.environ["SLACK_BOT_TOKEN"]
ADMIN_SLACK_ID = os.environ["ADMIN_SLACK_ID"]  # 管理者のSlackユーザーID
TECH_RANDOM_CH_ID = os.environ["TECH_RANDOM_CH_ID"]  # 投稿先のSlackチャンネルのID
TECH_RANDOM_CH_NAME = "#tech-random"
# OGPイメージが取得できなかったときに表示する画像
DEFAULT_OGP_IMAGE = os.environ["DEFAULT_OGP_IMAGE"]
NOTION_APP_TOKEN = os.environ["NOTION_APP_TOKEN"]
NOTION_DATABASE_ID = os.environ["NOTION_DATABASE_ID"]
NOTION_DATABASE_URL = os.environ["NOTION_DATABASE_URL"]
OPENAI_API_KEY = os.environ["OPENAI_API_KEY"]

openai.api_key = OPENAI_API_KEY

category_json_file = open("category_dict.json", 'r')
CATEGORY_DICT = json.load(category_json_file)
functions_json_file = open("functions_dict.json", 'r')
FUNCTIONS_DICT = json.load(functions_json_file)

app = App(token=SLACK_BOT_TOKEN)


class ArticleSummarizer:
    """
    与えられたイベントに基づいて、記事のサマリーを生成し、関連情報を取得・投稿するクラス。
    """
    MAX_TOKENS = 20000
    TOKEN_LIMIT = 16000
    MESSAGE_TRUNCATE_LENGTH = 1000

    def __init__(self, event, say, thread_ts=None):
        """
        初期化メソッド。イベント情報を基に、関連する属性を設定する。
        """
        def get_link(text):
            pattern = "https?://[\w/:%#\$&\?\(\)~\.=\+\-]+"
            return re.findall(pattern, text)

        def get_title_from_url():
            r = requests.get(self.url)
            soup = BeautifulSoup(r.content, "html.parser")
            return soup.find("title").text
        self.event = event
        self.say = say
        self.thread_ts = thread_ts
        self.url = get_link(event['text'])[0]
        self.user = event['user']
        self.title_origin = get_title_from_url()
        self.title = ""
        self.summary_json, self.ogp_image = self.generate_summary_from_url(self.url)

    def handle_error(self, e):
        """
        エラーハンドリングを行い、エラーメッセージを通知する。
        """
        self.say(
            f"Error occurred. Contact <{ADMIN_SLACK_ID}>:\n{traceback.format_exc()}")
        print(f"Error occurred: {traceback.format_exc()}")

    def generate_summary_from_url(self, url):
        """
        URLを引数に取り、そのコンテンツを抽出して要約とタグを生成する。
        返り値: 要約とタグのjsonオブジェクト、記事のタイトル、ogp画像。
        """
        def extract_content_from_url(url):
            """URLからコンテンツとタイトルを抽出するヘルパー関数"""
            res = requests.get(url)
            html = res.text
            extractor = ExtractContent()
            opt = {"threshold": 0}
            extractor.set_option(opt)
            extractor.analyse(html)
            text, _ = extractor.as_text()
            soup = BeautifulSoup(html, "html.parser")
            title = soup.find("title").text
            return text, title, soup

        def extract_ogp_image(soup):
            """OGP画像を抽出するヘルパー関数"""
            og_image_elems = soup.select('[property="og:image"]')
            for og_image_elem in og_image_elems:
                return og_image_elem.get("content")
            return None

        def get_tag_existing_list():
            notion = Client(auth=NOTION_APP_TOKEN)
            db = notion.databases.query(
                **{
                    'database_id': NOTION_DATABASE_ID  # データベースID
                }
            )
            tag_existing_list = []
            for i in db["results"]:
                for j in i["properties"]["タグ"]['multi_select']:
                    tag_existing_list.append(j["name"])
            tag_existing_list = list(set(tag_existing_list))
            return tag_existing_list
        text, title, soup = extract_content_from_url(url)
        ogp_image = extract_ogp_image(soup)
        # 既存のタグを抽出
        tag_existing_list = get_tag_existing_list()
        # GPT-3.5-turboを呼び出して要約とタグを生成
        tag_attention_str = "タグの例は以下です。タグの個数は5個以下でお願いいたします。" + \
            ''.join("\n- " + i for i in tag_existing_list)
        tokens_count = self.MAX_TOKENS
        while tokens_count >= self.TOKEN_LIMIT:
            messages = [
                {"role": "system", "content": "You are a helpful assistant."},
                {"role": "assistant", "content": f"【Title】{title}\n###\n{text}"},
                {"role": "user", "content": f"この記事の内容について、技術的な視点で要約とタグ付けをしてください。{tag_attention_str}\nlang:ja"},
            ]
            messages_txt = ''.join(message["content"] for message in messages)
            encoding: Encoding = tiktoken.encoding_for_model("gpt-3.5-turbo")
            tokens = encoding.encode(messages_txt)
            tokens_count = len(tokens)
            text = text[:-self.MESSAGE_TRUNCATE_LENGTH]
            functions = [FUNCTIONS_DICT]
        response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo-16k",
            temperature=0.0,
            messages=messages,
            functions=functions,
            function_call={"name": "i_am_json"},
        )
        message = response["choices"][0]["message"]
        return json.loads(message["function_call"]["arguments"]), ogp_image

    def generate_and_send_summary(self):
        """
        サマリーと関連情報を取得し、レスポンスとして投稿するメインメソッド。
        """
        try:
            summaries, tag_str, category_name, notion_url = self.prepare_summary()
            self.send_summary_to_slack(summaries, tag_str, category_name, notion_url)
        except Exception as e:
            # どこかでコケたらエラー処理する
            self.handle_error(e)

    def prepare_summary(self):
        """
        サマリーと関連情報を準備する。OGP画像の設定、サマリーの生成、カテゴリーの判定、Notionへの挿入を行う。
        """
        def judge_category(text):
            """
            与えられたテキストから、最も関連性が高いカテゴリーを決定する。
            """
            def calculate_category_score(category_words):
                # カテゴリーの単語リストを基に、テキストとの関連性スコアを計算する。
                return sum(word_score for word, word_score in category_words.items() if word in text)

            categories_scores = {
                category_name: calculate_category_score(category_data["word_dict"])
                for category_name, category_data in CATEGORY_DICT.items()
            }
            return max(categories_scores, key=categories_scores.get, default="12.その他")

        def make_summary_tag():
            # サマリーの作成
            summaries = "\n".join(
                "• " + (self.summary_json["summary"][f"summary{i+1}"][:125] + "(以下略)" if len(self.summary_json["summary"][f"summary{i+1}"]) >= 125 else self.summary_json["summary"][f"summary{i+1}"])
                for i in range(5) if f"summary{i+1}" in self.summary_json["summary"]
            )
            # タグlistの作成
            tag_list = []
            for tag_data in self.summary_json["tags"]:
                tag = tag_data["tag"] if isinstance(tag_data, dict) else tag_data
                tag_list.append({"name": tag})
            tag_str = " / ".join([tag["name"] for tag in tag_list])
            return summaries, tag_str, tag_list

        def insert_notion_database(summaries, tag_list, category_name):
            ogp_image = self.ogp_image
            if "https://qiita-user-contents.imgix.net" in self.ogp_image:
                ogp_image = self.ogp_image.replace("%", "%25")
            notion = Client(auth=os.environ['NOTION_APP_TOKEN'])
            response = notion.pages.create(
                **{
                    'parent': {'database_id': NOTION_DATABASE_ID},
                    'properties': {
                        '名前': {'title': [{'text': {'content': self.title}}]},
                        '要約': {'rich_text': [{'text': {'content': summaries}}]},
                        'URL': {'url': self.url},
                        'タグ': {'multi_select': tag_list},
                        'カテゴリ': {"select": {"name": category_name}},
                    },
                    "children": [
                        {
                            "object": 'block',
                            "type": 'image',
                            "image": {"type": "external", "external": {"url": ogp_image}}
                        }
                    ]
                }
            )
            notion_url = response["url"]
            return summaries, notion_url
        if self.ogp_image is None:
            self.ogp_image = DEFAULT_OGP_IMAGE
        summaries, tag_str, tag_list = make_summary_tag()
        category_name = judge_category(self.title + "\n" + summaries + "\n" + tag_str)
        summaries, notion_url = insert_notion_database(summaries, tag_list, category_name)
        return summaries, tag_str, category_name, notion_url

    def send_summary_to_slack(self, summaries, tag_str, category_name, notion_url):
        """
        生成されたサマリーと関連情報を基に、レスポンスメッセージを作成して投稿する。
        """
        self.title = f"<{self.url}|*{self.title_origin}*> "
        tag_str = f"*[タグ]* {tag_str} "
        summaries = f"```{summaries}```"
        text_notion = f":notion: <{notion_url}|記事>、<https://www.notion.so/{NOTION_DATABASE_URL}|まとめ>"
        if self.thread_ts is None:
            # DMで返信
            self.say(self.title + "\n" + summaries + "\n" + tag_str + "\n`" + category_name + "`\n" + text_notion)
        # チャンネルに投稿
        self.send_message_to_channel(
             summaries, tag_str, category_name, text_notion, self.user, self.ogp_image)

    def send_message_to_channel(self, text_summary, text_tag, text_category, text_notion, user, ogp_image, thread_ts=None):
        """
        Slackの特定のチャンネルにメッセージを送信する。
        """
        def send_message(client, text_title, attachments, thread_ts=None):
            """Slackへのメッセージの投稿を助けるヘルパー関数"""
            params = {
                "text": text_title,
                "channel": TECH_RANDOM_CH_NAME,
                "attachments": attachments
            }
            if thread_ts:
                params["thread_ts"] = thread_ts
            response = client.chat_postMessage(**params)
            return response

        attachments_0 = [
            {
                "color": CATEGORY_DICT[text_category]["color"],
                "blocks": [
                    {
                        "type": "section",
                        "text": {
                            "type": "mrkdwn",
                            "text": self.title+"\n"+text_tag
                        },
                        "accessory": {
                            "type": "image",
                            "image_url": ogp_image,
                            "alt_text": "ogp_image"
                        }
                    },
                    {
                        "type": "context",
                        "elements": [
                            {
                                "type": "mrkdwn",
                                "text": f"{text_notion} by <@{user}> `{text_category}`"
                            }
                        ]
                    }
                ]
            }
        ]
        attachments_1 = [
            {
                "color": CATEGORY_DICT[text_category]["color"],
                "blocks": [
                    {
                        "type": "section",
                        "text": {
                            "type": "mrkdwn",
                            "text": text_summary
                        }
                    }
                ]
            }
        ]
        client = WebClient(os.environ["SLACK_BOT_TOKEN"])
        if thread_ts is None:
            response = send_message(client, None,  attachments_0)
            send_message(client,self.title_origin, attachments_1, response["ts"])
        else:
            send_message(client, None,attachments_0, thread_ts)
            send_message(client, self.title_origin,  attachments_1, thread_ts)


@app.message("")  # DMでリンクが送られたときのハンドラ
def reply_message(event, say):
    if event['channel_type'] == "im":
        asc = ArticleSummarizer(event, say)
        asc.generate_and_send_summary()


@app.event("app_mention")
def reply_mention(event, say):
    thread_ts = event["ts"]
    if event["channel"] == TECH_RANDOM_CH_ID:
        asc = ArticleSummarizer(event, say, thread_ts)
        asc.generate_and_send_summary()


@app.event("message")
def handle_message_events(body, logger):
    logger.info(body)

SocketModeHandler(app, SLACK_APP_TOKEN).start()