from telegram import (
    Update,
    InlineKeyboardButton,
    InlineKeyboardMarkup,
    LinkPreviewOptions,
)
from telegram.constants import ParseMode
from telegram.ext import ContextTypes

import html_parser
from datetime import datetime
from config import *
from extensions import get_json, format_rating, format_status, humanize_filesize


async def start_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text(
        f"hello, i'm {html_parser.bold(context.bot.first_name)}, an inline image grabber.\n\n"
        f"to get help, use /help",
        parse_mode=ParseMode.HTML,
    )


async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text(
        f"{html_parser.bold(f"how to use {context.bot.first_name}")}\n\n"
        f"1. open your message box and type:\n"
        f"{html_parser.code(f"@{context.bot.username} <post ID>")}\n"
        f"2. click on the box that has popped up\n"
        f"3. ???\n"
        f"4. done!",
        parse_mode=ParseMode.HTML,
    )


async def about_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    reply_markup = None
    if general.sourceurl is not None:
        keyboard = [[InlineKeyboardButton(f"source code", url=general.sourceurl)]]
        reply_markup = InlineKeyboardMarkup(keyboard)

    await update.message.reply_text(
        f"{html_parser.bold(f"about {context.bot.first_name}")}\n"
        f"{context.bot.first_name} is an inline image grabber written in python that grabs images from Danbooru "
        f"(or other similar services).\n\n"
        f"{html_parser.bold("currently configured instance:")}\n"
        f"{html_parser.italic(app.name)} ({app.hostname})",
        parse_mode=ParseMode.HTML,
        reply_markup=reply_markup,
    )


async def info_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    try:
        post_id = context.args[0]
        message = await context.bot.send_message(
            update.effective_chat.id,
            f"{html_parser.bold("Information")}\n" f"Fetching...",
            parse_mode=ParseMode.HTML,
        )
        post_data = get_json(f"posts/{post_id}")
        if post_data is None:
            await context.bot.edit_message_text(
                f"{html_parser.bold("Error")}: That record was not found.",
                update.effective_chat.id,
                message.message_id,
                parse_mode=ParseMode.HTML,
            )
            return
        uploader_data = get_json(f"users/{post_data['uploader_id']}")
        # well, we could check the uploader, but why would we do that?

        keyboard = [
            [
                InlineKeyboardButton(
                    f"Open in {app.name}",
                    url=f"{app.protocol}://{app.hostname}/posts/{post_id}",
                )
            ]
        ]
        reply_markup = InlineKeyboardMarkup(keyboard)

        m = [
            " ".join(["ID:", html_parser.code(post_data["id"])]),
            " ".join(
                [
                    "Uploader:",
                    html_parser.hyperlink(
                        uploader_data["name"],
                        f"{app.protocol}://{app.hostname}/users/{post_data['uploader_id']}",
                    ),
                    html_parser.hyperlink(
                        "»",
                        f"{app.protocol}://{app.hostname}/posts?tags=user:{uploader_data['name']}",
                    ),
                ]
            ),
        ]
        created_at = datetime.fromisoformat(post_data["created_at"])
        m.append(
            " ".join(
                [
                    "Date:",
                    html_parser.hyperlink(
                        created_at.strftime("%Y-%m-%d %X (%z)"),
                        f"{app.protocol}://{app.hostname}/posts?tags=date:{created_at.strftime("%Y-%m-%d")}",
                    ),
                ]
            )
        )
        if post_data["approver_id"] is not None:
            approver_data = get_json(f"users/{post_data['approver_id']}")
            m.append(
                " ".join(
                    [
                        "Approver:",
                        html_parser.hyperlink(
                            approver_data["name"],
                            f"{app.protocol}://{app.hostname}/users/{post_data['approver_id']}",
                        ),
                        html_parser.hyperlink(
                            "»",
                            f"{app.protocol}://{app.hostname}/posts?tags=approver:{approver_data['name']}",
                        ),
                    ]
                )
            )
        m.append(
            " ".join(
                [
                    "Size:",
                    html_parser.hyperlink(
                        f"{humanize_filesize(post_data['media_asset']['file_size'])} .{post_data['media_asset']['file_ext']}",
                        "" if post_data["is_banned"] else post_data["file_url"],
                    ),
                    f"({post_data['media_asset']['image_width']}x{post_data['media_asset']['image_height']})",
                    html_parser.hyperlink(
                        "»",
                        f"{app.protocol}://{app.hostname}/media_assets/{post_data['media_asset']['id']}",
                    ),
                ]
            )
        )
        m.append(
            " ".join(
                ["Source:", post_data["source"] if post_data["source"] != "" else "🚫"]
            )
        )
        m.append(" ".join(["Rating:", format_rating(post_data["rating"])]))
        m.append(
            " ".join(
                [
                    "Score:",
                    html_parser.hyperlink(
                        post_data["score"],
                        f"{app.protocol}://{app.hostname}/post_votes?search[post_id]={post_data['id']}&variant=compact",
                    ),
                    f"(+{post_data['up_score']} / -{post_data['down_score']})",
                ]
            )
        )
        m.append(
            " ".join(
                [
                    "Favorites:",
                    html_parser.hyperlink(
                        post_data["fav_count"],
                        f"{app.protocol}://{app.hostname}/posts/{post_data['id']}/favorites",
                    ),
                ]
            )
        )
        m.append(" ".join(["Status:", format_status(post_data)]))

        link_preview_options = LinkPreviewOptions(True)
        if not post_data["is_banned"]:
            link_preview_options = LinkPreviewOptions(url=post_data["large_file_url"])

        await context.bot.edit_message_text(
            "\n".join([html_parser.bold("Information")] + m),
            update.effective_chat.id,
            message.message_id,
            parse_mode=ParseMode.HTML,
            reply_markup=reply_markup,
            link_preview_options=link_preview_options,
        )
    except (IndexError, ValueError):
        await update.message.reply_text(
            " ".join(
                [html_parser.bold("Usage:"), html_parser.code("/info <post ID>")]
            ),
            parse_mode=ParseMode.HTML,
        )