import base64
import os
import pathlib
import json5
import logging
import shutil
import time
import streamlit as st
import streamlit.runtime.scriptrunner as st_sr
from typing import List, Tuple
import metaphor_python as metaphor
import tempfile

import llm_helper
import pptx_helper
from global_config import GlobalConfig


APP_TEXT = json5.loads(open(GlobalConfig.APP_STRINGS_FILE, 'r').read())
GB_CONVERTER = 2 ** 30


logging.basicConfig(
    level=GlobalConfig.LOG_LEVEL,
    format='%(asctime)s - %(message)s',
)


@st.cache_data
def get_contents_wrapper(text: str) -> str:
    """
    Fetch and cache the slide deck contents on a topic by calling an external API.

    :param text: The presentation topic
    :return: The slide deck contents or outline in JSON format
    """

    logging.info('LLM call because of cache miss...')
    return llm_helper.generate_slides_content(text).strip()


@st.cache_resource
def get_metaphor_client_wrapper() -> metaphor.Metaphor:
    """
    Create a Metaphor client for semantic Web search.

    :return: Metaphor instance
    """

    return metaphor.Metaphor(api_key=GlobalConfig.METAPHOR_API_KEY)


@st.cache_data
def get_web_search_results_wrapper(text: str) -> List[Tuple[str, str]]:
    """
    Fetch and cache the Web search results on a given topic.

    :param text: The topic
    :return: A list of (title, link) tuples
    """

    results = []
    search_results = get_metaphor_client_wrapper().search(
        text,
        use_autoprompt=True,
        num_results=5
    )

    for a_result in search_results.results:
        results.append((a_result.title, a_result.url))

    return results


@st.cache_data
def get_ai_image_wrapper(text: str) -> str:
    """
    Fetch and cache a Base 64-encoded image by calling an external API.

    :param text: The image prompt
    :return: The Base 64-encoded image
    """

    return llm_helper.get_ai_image(text)


def get_disk_used_percentage() -> float:
    """
    Compute the disk usage.

    :return: Percentage of the disk space currently used
    """

    total, used, free = shutil.disk_usage(__file__)
    total = total // GB_CONVERTER
    used = used // GB_CONVERTER
    free = free // GB_CONVERTER
    used_perc = 100.0 * used / total

    logging.debug(f'Total: {total} GB\n'
                  f'Used: {used} GB\n'
                  f'Free: {free} GB')

    logging.debug('\n'.join(os.listdir()))

    return used_perc


def build_ui():
    """
    Display the input elements for content generation. Only covers the first step.
    """

    # get_disk_used_percentage()

    st.title(APP_TEXT['app_name'])
    st.subheader(APP_TEXT['caption'])

    with st.form('my_form'):
        # Topic input
        try:
            with open(GlobalConfig.PRELOAD_DATA_FILE, 'r') as in_file:
                preload_data = json5.loads(in_file.read())
        except (FileExistsError, FileNotFoundError):
            preload_data = {'topic': '', 'audience': ''}

        topic = st.text_area(
            APP_TEXT['input_labels'][0],
            value=preload_data['topic']
        )

        texts = list(GlobalConfig.PPTX_TEMPLATE_FILES.keys())
        captions = [GlobalConfig.PPTX_TEMPLATE_FILES[x]['caption'] for x in texts]

        pptx_template = st.radio(
            'Select a presentation template:',
            texts,
            captions=captions,
            horizontal=True
        )

        st.divider()
        submit = st.form_submit_button('Generate slide deck')

    if submit:
        # st.write(f'Clicked {time.time()}')
        st.session_state.submitted = True

    # https://github.com/streamlit/streamlit/issues/3832#issuecomment-1138994421
    if 'submitted' in st.session_state:
        progress_text = 'Generating the slides...give it a moment'
        progress_bar = st.progress(0, text=progress_text)

        topic_txt = topic.strip()
        generate_presentation(topic_txt, pptx_template, progress_bar)

    st.divider()
    st.text(APP_TEXT['tos'])
    st.text(APP_TEXT['tos2'])

    st.markdown(
        '![Visitors](https://api.visitorbadge.io/api/visitors?path=https%3A%2F%2Fhuggingface.co%2Fspaces%2Fbarunsaha%2Fslide-deck-ai&countColor=%23263759)'
    )


def generate_presentation(topic: str, pptx_template: str, progress_bar):
    """
    Process the inputs to generate the slides.

    :param topic: The presentation topic based on which contents are to be generated
    :param pptx_template: The PowerPoint template name to be used
    :param progress_bar: Progress bar from the page
    :return:
    """

    topic_length = len(topic)
    logging.debug(f'Input length:: topic: {topic_length}')

    if topic_length >= 10:
        logging.debug(
            f'Topic: {topic}\n'
        )

        target_length = min(topic_length, GlobalConfig.LLM_MODEL_MAX_INPUT_LENGTH)

        try:
            # Step 1: Generate the contents in JSON format using an LLM
            json_str = process_slides_contents(topic[:target_length], progress_bar)

            # Step 2: Generate the slide deck based on the template specified
            if len(json_str) > 0:
                st.info(
                    'Tip: The generated content doesn\'t look so great?'
                    ' Need alternatives? Just change your description text and try again.',
                    icon="💡️"
                )
            else:
                st.error('Unfortunately, JSON generation failed, so the next steps would lead to nowhere.'
                         ' Try again or come back later.')
                return

            all_headers = generate_slide_deck(json_str, pptx_template, progress_bar)

            # Step 3: Bonus stuff: Web references and AI art
            show_bonus_stuff(all_headers)

        except ValueError as ve:
            st.error(f'Unfortunately, an error occurred: {ve}! '
                     f'Please change the text, try again later, or report it, sharing your inputs.')

    else:
        st.error('Not enough information provided! Please be little more descriptive :)')


def process_slides_contents(text: str, progress_bar: st.progress) -> str:
    """
    Convert given text into structured data and display. Update the UI.

    :param text: The topic description for the presentation
    :param progress_bar: Progress bar for this step
    :return: The contents as a JSON-formatted string
    """

    json_str = ''

    try:
        logging.info(f'Calling LLM for content generation on the topic: {text}')
        json_str = get_contents_wrapper(text)
    except Exception as ex:
        st.error(f'An exception occurred while trying to convert to JSON.'
                 f' It could be because of heavy traffic or something else.'
                 f' Try doing it again or try again later.\n'
                 f' Error message: {ex}')

    logging.debug(f'JSON: {json_str}')

    progress_bar.progress(50, text='Contents generated')

    with st.expander('The generated contents (in JSON format)'):
        st.code(json_str, language='json')

    return json_str


def generate_slide_deck(json_str: str, pptx_template: str, progress_bar) -> List:
    """
    Create a slide deck.

    :param json_str: The contents in JSON format
    :param pptx_template: The PPTX template name
    :param progress_bar: Progress bar
    :return: A list of all slide headers and the title
    """

    progress_text = 'Creating the slide deck...give it a moment'
    progress_bar.progress(75, text=progress_text)

    # # Get a unique name for the file to save -- use the session ID
    # ctx = st_sr.get_script_run_ctx()
    # session_id = ctx.session_id
    # timestamp = time.time()
    # output_file_name = f'{session_id}_{timestamp}.pptx'

    temp = tempfile.NamedTemporaryFile(delete=False, suffix='.pptx')
    path = pathlib.Path(temp.name)

    logging.info('Creating PPTX file...')
    all_headers = pptx_helper.generate_powerpoint_presentation(
        json_str,
        as_yaml=False,
        slides_template=pptx_template,
        output_file_path=path
    )
    progress_bar.progress(100, text='Done!')

    with open(path, 'rb') as f:
        st.download_button('Download PPTX file', f, file_name='Presentation.pptx')

    return all_headers


def show_bonus_stuff(ppt_headers: List[str]):
    """
    Show bonus stuff for the presentation.

    :param ppt_headers: A list of the slide headings.
    """

    # Use the presentation title and the slide headers to find relevant info online
    logging.info('Calling Metaphor search...')
    ppt_text = ' '.join(ppt_headers)
    search_results = get_web_search_results_wrapper(ppt_text)
    md_text_items = []

    for (title, link) in search_results:
        md_text_items.append(f'[{title}]({link})')

    with st.expander('Related Web references'):
        st.markdown('\n\n'.join(md_text_items))

    # Avoid image generation. It costs time and an API call, so just limit to the text generation.
    with st.expander('AI-generated image on the presentation topic'):
        logging.info('Calling SDXL for image generation...')
        # img_empty.write('')
        # img_text.write(APP_TEXT['image_info'])
        image = get_ai_image_wrapper(ppt_text)

        if len(image) > 0:
            image = base64.b64decode(image)
            st.image(image, caption=ppt_text)
            st.info('Tip: Right-click on the image to save it.', icon="💡️")
            logging.info('Image added')


def main():
    build_ui()


if __name__ == '__main__':
    main()