app.py

import base64
import io
import os
import pandas as pd
from docx import Document
from io import BytesIO
import dash
import dash_bootstrap_components as dbc
from dash import html, dcc, Input, Output, State, callback_context, ALL
from dash.dash_table import DataTable
from PyPDF2 import PdfReader
import logging
import threading
import re
import google.generativeai as genai
import sqlite3
import time

logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')

GEMINI_KEY = os.environ.get("GEMINI_KEY", "")
genai.configure(api_key=GEMINI_KEY)
GEMINI_MODEL = "gemini-2.5-pro-preview-03-25"

DB_PATH = "maiko_dash_docs.sqlite"

def init_db():
    with sqlite3.connect(DB_PATH) as conn:
        c = conn.cursor()
        c.execute('''CREATE TABLE IF NOT EXISTS uploaded_docs
                     (doc_type TEXT PRIMARY KEY, doc_content TEXT, file_name TEXT, last_update TIMESTAMP)''')
        c.execute('''CREATE TABLE IF NOT EXISTS generated_docs
                     (doc_type TEXT PRIMARY KEY, doc_content TEXT, last_update TIMESTAMP)''')
        conn.commit()
init_db()

def set_uploaded_doc(doc_type, doc_content, file_name):
    with sqlite3.connect(DB_PATH) as conn:
        c = conn.cursor()
        c.execute('''INSERT OR REPLACE INTO uploaded_docs (doc_type, doc_content, file_name, last_update)
                     VALUES (?, ?, ?, ?)''', (doc_type, doc_content, file_name, time.time()))
        conn.commit()

def get_uploaded_doc(doc_type):
    with sqlite3.connect(DB_PATH) as conn:
        c = conn.cursor()
        c.execute('''SELECT doc_content, file_name FROM uploaded_docs WHERE doc_type=?''', (doc_type,))
        row = c.fetchone()
        if row:
            return row[0], row[1]
        return None, None

def set_generated_doc(doc_type, doc_content):
    with sqlite3.connect(DB_PATH) as conn:
        c = conn.cursor()
        c.execute('''INSERT OR REPLACE INTO generated_docs (doc_type, doc_content, last_update)
                     VALUES (?, ?, ?)''', (doc_type, doc_content, time.time()))
        conn.commit()

def get_generated_doc(doc_type):
    with sqlite3.connect(DB_PATH) as conn:
        c = conn.cursor()
        c.execute('''SELECT doc_content FROM generated_docs WHERE doc_type=?''', (doc_type,))
        row = c.fetchone()
        if row:
            return row[0]
        return None

spreadsheet_types = ["Shred", "Pink Review", "Red Review", "Gold Review", "Virtual Board", "LOE"]
narrative_types = ["Pink", "Red", "Gold"]

document_types = {
    "Shred": "Ignore all other instructions and generate only requirements spreadsheet of the Project Work Statement (PWS) identified by action words like shall, will, perform etc. by pws section, requirement.  Do not write as if you're responding to the proposal.  Its a spreadsheet to distill the requirements, not microhealth's approach",
    "Pink": "Create a highly detailed Pink Team document based on the PWS outline.  Your goal is to be compliant and compelling.  Focus on describing the approach and how it will be done, the steps, workflow, people, processes and technology based on well known industry standards to accomplish the task.  Be sure to demonstrate innovation.",
    "Pink Review": "Ignore all other instructions and generate and evaluate compliance of the Pink Team document against the requirements and output only a spreadsheet of non compliant findings by pws number, the goal of that pws section, what made it non compliant and your recommendations for recovery. you must also take into account section L&M of the document which is the evaluation criteria to be sure we address them.",
    "Red": "Produce a  highly detailed Red Team document based on the Pink Review by pws sections. Your goal is to be compliant and compelling by recovering all the findings in Pink Review. Focus on describing the approach and how it will be done, the steps, workflow, people, processes and technology to accomplish the task. Be sure to refer to research that validates the approach and cite sources with measurable outcomes",
    "Red Review": "Ignore all other instructions and generate and evaluate compliance of the Red Team document against the requirements and output a only a spreadsheet of non compliant findings by pws number, the goal of that pws section, what made it non compliant and your recommendations for recovery. you must also take into account section L&M of the document which is the evaluation criteria to be sure we address them",
    "Gold": "Create a highly detailed Gold Team document based on the PWS response by pws sections. Your goal is to be compliant and compelling by recovering all the findings in Red Review.  Focus on describing the approach and how it will be done, the steps, workflow, people, processes and technology to accomplish the task. Be sure to refer to research that validates the approach and cite sources with measurable outcomes and improve on innovations of the approach",
    "Gold Review": "Ignore all other instructions and generate and perform a final compliance review against the requirements and output only a spreadsheet of non compliant findings by pws number, the goal of that pws section, what made it non compliant and your recommendations for recovery. you must also take into account section L&M of the document which is the evaluation criteria to be sure we address them",
    "Virtual Board": "Ignore all other instructions and generate and based on the requirements and in particular the evaulation criteria, you will evaluate the proposal as if you were a contracting office and provide section by section evaluation as unsatisfactory, satisfactory, good, very good, excellent and why and produce only spreadsheet",
    "LOE": "Ignore all other instructions and generate and generate a Level of Effort (LOE) breakdown and produce only spreadsheet"
}

doc_dependencies = {
    "Pink": {"source": ["shred"], "require": True},
    "Pink Review": {"source": ["pink", "shred"], "require": True},
    "Red": {"source": ["pink_review"], "require": True},
    "Red Review": {"source": ["red", "shred"], "require": True},
    "Gold": {"source": ["red_review"], "require": True},
    "Gold Review": {"source": ["gold", "shred"], "require": True},
    "LOE": {"source": ["gold"], "require": True},
    "Virtual Board": {"source": ["shred"], "require": True},
}

def extract_markdown_tables(md_text):
    tables = []
    lines = md_text.split('\n')
    in_table = False
    table_lines = []
    for line in lines:
        if re.match(r'^\s*\|.*\|\s*$', line):
            in_table = True
            table_lines.append(line)
        elif in_table and (re.match(r'^\s*\|.*\|\s*$', line) or re.match(r'^\s*$', line)):
            table_lines.append(line)
        else:
            if in_table and table_lines:
                tables.append('\n'.join(table_lines))
                table_lines = []
            in_table = False
    if in_table and table_lines:
        tables.append('\n'.join(table_lines))
    return tables

def markdown_table_to_df(md_table):
    lines = [line.strip() for line in md_table.split('\n') if line.strip()]
    if len(lines) < 2:
        return None
    header = [h.strip() for h in lines[0].strip('|').split('|')]
    sep_idx = 1
    while sep_idx < len(lines) and not re.match(r'^\|\s*:?-+:?\s*(\|\s*:?-+:?\s*)+\|?$', lines[sep_idx]):
        sep_idx += 1
    data_lines = lines[sep_idx+1:] if sep_idx+1 < len(lines) else []
    rows = []
    for row in data_lines:
        if not row.strip() or not row.strip().startswith('|'):
            continue
        cells = [c.strip() for c in row.strip('|').split('|')]
        if len(cells) < len(header):
            cells += [''] * (len(header) - len(cells))
        elif len(cells) > len(header):
            cells = cells[:len(header)]
        rows.append(cells)
    df = pd.DataFrame(rows, columns=header)
    return df

def markdown_table_preview(md_text):
    if not md_text:
        return html.Div()
    tables = extract_markdown_tables(md_text)
    if not tables:
        return html.Div()
    table_divs = []
    for i, table in enumerate(tables):
        df = markdown_table_to_df(table)
        if df is not None and not df.empty:
            table_divs.append(
                html.Div([
                    DataTable(
                        columns=[{"name": str(col), "id": str(col)} for col in df.columns],
                        data=df.to_dict('records'),
                        style_table={'overflowX': 'auto'},
                        style_cell={'whiteSpace': 'normal', 'height': 'auto', 'textAlign': 'left', 'fontFamily': 'monospace', 'fontSize': '14px', 'maxWidth': '400px', 'minWidth': '80px', 'wordBreak': 'break-word'},
                        style_header={'fontWeight': 'bold'},
                        page_size=100,
                        id={'type': 'datatable-preview', 'index': i}
                    )
                ], className="mb-4")
            )
    return html.Div(table_divs)

def markdown_narrative_preview(md_text):
    return html.Div(dcc.Markdown(md_text or "", dangerously_allow_html=True, style={'whiteSpace': 'pre-wrap', 'fontFamily': 'sans-serif'}))

def markdown_tables_to_xlsx(md_text):
    tables = extract_markdown_tables(md_text)
    output = BytesIO()
    with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
        for i, table in enumerate(tables):
            df = markdown_table_to_df(table)
            if df is not None:
                sheet_name = f"Table{i+1}"
                df.to_excel(writer, sheet_name=sheet_name, index=False)
    output.seek(0)
    return output

def strip_markdown(text):
    text = re.sub(r'(\*\*|__)(.*?)\1', r'\2', text)
    text = re.sub(r'(\*|_)(.*?)\1', r'\2', text)
    text = re.sub(r'`{1,3}[^`]*`{1,3}', '', text)
    text = re.sub(r'^#+ ', '', text, flags=re.MULTILINE)
    text = re.sub(r'^> ', '', text, flags=re.MULTILINE)
    text = re.sub(r'!\[.*?\]\(.*?\)', '', text)
    text = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', text)
    text = re.sub(r'^\s*[-*+] ', '', text, flags=re.MULTILINE)
    text = re.sub(r'^\s*\d+\.\s+', '', text, flags=re.MULTILINE)
    text = text.replace('---', '')
    text = text.replace('___', '')
    text = text.replace('***', '')
    return text.strip()

def process_document(contents, filename):
    content_type, content_string = contents.split(',')
    decoded = base64.b64decode(content_string)
    try:
        if filename.lower().endswith('.docx'):
            doc = Document(BytesIO(decoded))
            text = "\n".join([para.text for para in doc.paragraphs])
            return text
        elif filename.lower().endswith('.pdf'):
            pdf = PdfReader(BytesIO(decoded))
            text = ""
            for page in pdf.pages:
                page_text = page.extract_text()
                if page_text:
                    text += page_text
            return text
        else:
            return f"Unsupported file format: {filename}. Please upload a PDF or DOCX file."
    except Exception as e:
        logging.error(f"Error processing document: {str(e)}")
        return f"Error processing document: {str(e)}"

def file_list_component():
    return html.Div(
        id='file-list-container',
        children=[
            html.Div(id='file-list')
        ]
    )

def get_left_col_content():
    chat_card = dbc.Card(
        dbc.CardBody([
            html.H5("Maiko Chat", className="mb-2"),
            dcc.Loading(
                id="chat-loading",
                type="dot",
                children=[
                    dcc.Textarea(
                        id="chat-input",
                        placeholder="Chat with AI to update document...",
                        className="mb-2",
                        style={
                            'whiteSpace':'pre-wrap',
                            'width': '100%',
                            'minHeight': '100px',
                            'maxHeight': '300px',
                            'resize': 'vertical',
                            'overflowY': 'auto'
                        },
                        rows=5,
                        wrap='soft'
                    ),
                    dbc.Row([
                        dbc.Col(
                            dbc.Button("Send", id="btn-send-chat", color="primary", className="mb-3 w-100"),
                            width=6
                        ),
                        dbc.Col(
                            dbc.Button("Clear Chat", id="btn-clear-chat", color="secondary", className="mb-3 w-100"),
                            width=6
                        ),
                    ], className="g-1 mb-2"),
                    html.Div(id="chat-output")
                ]
            )
        ]),
        className="mt-4"
    )
    return [
        html.H4("Proposal Writer", className="mt-3 mb-2", style={'marginBottom': '12px'}),
        html.Hr(style={'marginTop': '8px', 'marginBottom': '16px'}),
        html.Div(
            id='doc-type-buttons'
        ),
        chat_card
    ]

def get_right_col_content(selected_type, store_data):
    controls = []
    controls.append(dcc.Loading(
        id="loading-indicator",
        type="dot",
        children=[html.Div(id="loading-output")]
    ))

    if selected_type == "Shred":
        controls.append(
            html.Div([
                dcc.Upload(
                    id={'type': 'upload-doc-type', 'subtype': 'shred', 'index': selected_type},
                    children=html.Div([
                        'Drag and Drop or ',
                        html.A('Select Files')
                    ]),
                    style={
                        'width': '100%',
                        'height': '60px',
                        'lineHeight': '60px',
                        'borderWidth': '1px',
                        'borderStyle': 'dashed',
                        'borderRadius': '5px',
                        'textAlign': 'center',
                        'margin': '10px 0'
                    },
                    multiple=True
                ),
                file_list_component(),
                html.Div(id='uploaded-doc-name-shred')
            ])
        )
    elif selected_type in doc_dependencies:
        sources = doc_dependencies[selected_type]["source"]
        for src in sources:
            label = ""
            loaded_preview = None
            store_var = store_data.get(src)
            doc_name_id = f"uploaded-doc-name-{src}"
            if src == "shred":
                label = "Shred (Requirements)"
                loaded_preview = markdown_table_preview(store_var)
            elif src == "pink":
                label = "Pink Document"
                loaded_preview = markdown_narrative_preview(store_var)
            elif src == "pink_review":
                label = "Pink Review"
                loaded_preview = markdown_table_preview(store_var)
            elif src == "red":
                label = "Red Document"
                loaded_preview = markdown_narrative_preview(store_var)
            elif src == "red_review":
                label = "Red Review"
                loaded_preview = markdown_table_preview(store_var)
            elif src == "gold":
                label = "Gold Document"
                loaded_preview = markdown_narrative_preview(store_var)
            controls.append(html.Div([
                html.Label(f"Upload {label}"),
                dcc.Upload(
                    id={'type': 'upload-doc-type', 'subtype': src, 'index': selected_type},
                    children=html.Div(['Drag and Drop or ', html.A('Select File')]),
                    style={
                        'width': '100%',
                        'height': '60px',
                        'lineHeight': '60px',
                        'borderWidth': '1px',
                        'borderStyle': 'dashed',
                        'borderRadius': '5px',
                        'textAlign': 'center',
                        'margin': '10px 0'
                    },
                    multiple=False
                ),
                html.Div(id=doc_name_id),
                dbc.RadioItems(
                    id={'type': 'radio-doc-source', 'subtype': src, 'index': selected_type},
                    options=[
                        {'label': 'Loaded Document', 'value': 'loaded'}
                    ] if store_var else [],
                    value='loaded' if store_var else None,
                    inline=True,
                    className="mb-2"
                ),
                html.Div([
                    html.Div("Loaded Document Preview:", className="mt-2 mb-1"),
                    loaded_preview
                ], style={'marginBottom': '12px'}),
            ], id={'type': f'doc-type-controls-{src}', 'index': selected_type}))
    controls.append(
        dbc.Row([
            dbc.Col(
                dbc.Button("Generate Document", id={'type': 'btn-generate-doc', 'index': selected_type}, color="primary", className="mb-3 w-100"),
                width=6
            ),
            dbc.Col(
                dbc.Button("Download Document", id="btn-download", color="success", className="mb-3 w-100"),
                width=6
            ),
            dcc.Download(id="download-document")
        ], className="mb-2")
    )
    controls.append(html.Hr())
    controls.append(html.Div(id='document-preview', className="border p-3 mb-3"))
    return dbc.Card(dbc.CardBody(controls))

app = dash.Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP], suppress_callback_exceptions=True)

app.layout = dbc.Container([
    dcc.Store(id='selected-doc-type', data="Shred"),
    dcc.Store(id='store-shred'),
    dcc.Store(id='store-pink'),
    dcc.Store(id='store-pink-review'),
    dcc.Store(id='store-red'),
    dcc.Store(id='store-red-review'),
    dcc.Store(id='store-gold'),
    dcc.Store(id='store-gold-review'),
    dcc.Store(id='store-loe'),
    dcc.Store(id='store-virtual-board'),
    dcc.Store(id='store-generated-doc'),
    dcc.Store(id='progress-dot-store'),
    dbc.Row([
        dbc.Col(
            html.H2(id='main-title', className="mt-3 mb-2", style={'textAlign': 'center', 'width':'100%'}),
            width=12
        )
    ]),
    dbc.Row([
        dbc.Col(
            dcc.Loading(
                id="main-progress-dot",
                type="dot",
                children=html.Div(id="main-progress-dot-output")
            ),
            width=12,
            style={'textAlign':'center', 'marginBottom':'10px'}
        )
    ]),
    dbc.Row([
        dbc.Col(
            dbc.Card(
                dbc.CardBody(get_left_col_content())
            ),
            width=3
        ),
        dbc.Col(
            html.Div(id='right-col-content'),
            width=9
        )
    ])
], fluid=True)

@app.callback(
    Output('main-title', 'children'),
    Input('selected-doc-type', 'data')
)
def update_main_title(selected_type):
    return selected_type

@app.callback(
    Output('doc-type-buttons', 'children'),
    Input('selected-doc-type', 'data')
)
def render_doc_type_buttons(selected_type):
    buttons = []
    for doc_type in document_types.keys():
        btn_style = {'overflow': 'hidden', 'text-overflow': 'ellipsis', 'white-space': 'nowrap'}
        btn_class = "mb-2 w-100 text-left custom-button"
        if doc_type == selected_type:
            btn_class += " active-doc-type"
        buttons.append(
            dbc.Button(
                doc_type,
                id={'type': 'btn-doc-type', 'index': doc_type},
                color="link",
                className=btn_class,
                style=btn_style
            )
        )
    return buttons

@app.callback(
    Output('selected-doc-type', 'data'),
    [Input({'type': 'btn-doc-type', 'index': ALL}, 'n_clicks')],
    [State({'type': 'btn-doc-type', 'index': ALL}, 'id')],
    prevent_initial_call=True
)
def update_selected_doc_type(n_clicks_list, btn_ids):
    triggered = callback_context.triggered
    if not triggered or all(x is None for x in n_clicks_list):
        raise dash.exceptions.PreventUpdate
    idx = [i for i, x in enumerate(n_clicks_list) if x]
    if idx:
        selected_type = btn_ids[idx[-1]]['index']
    else:
        selected_type = "Shred"
    logging.info(f"Doc type selected: {selected_type}")
    return selected_type

@app.callback(
    Output('right-col-content', 'children'),
    Input('selected-doc-type', 'data'),
)
def update_right_col(selected_type):
    store_data = {}
    for store_key in ["shred","pink","pink_review","red","red_review","gold","gold_review","loe","virtual_board"]:
        doc_content, _ = get_uploaded_doc(store_key)
        store_data[store_key] = doc_content
    return get_right_col_content(selected_type, store_data)

@app.callback(
    [
        Output('store-shred', 'data'),
        Output('store-pink', 'data'),
        Output('store-pink-review', 'data'),
        Output('store-red', 'data'),
        Output('store-red-review', 'data'),
        Output('store-gold', 'data'),
        Output('store-gold-review', 'data'),
        Output('store-loe', 'data'),
        Output('store-virtual-board', 'data'),
        Output('file-list', 'children'),
        Output('uploaded-doc-name-shred', 'children'),
        Output('uploaded-doc-name-pink', 'children'),
        Output('uploaded-doc-name-pink_review', 'children'),
        Output('uploaded-doc-name-red', 'children'),
        Output('uploaded-doc-name-red_review', 'children'),
        Output('uploaded-doc-name-gold', 'children'),
        Output('uploaded-doc-name-gold_review', 'children'),
        Output('uploaded-doc-name-loe', 'children'),
        Output('uploaded-doc-name-virtual_board', 'children'),
        Output('progress-dot-store', 'data')
    ],
    [
        Input({'type': 'upload-doc-type', 'subtype': ALL, 'index': ALL}, 'contents'),
    ],
    [
        State({'type': 'upload-doc-type', 'subtype': ALL, 'index': ALL}, 'filename'),
        State('store-shred', 'data'),
        State('store-pink', 'data'),
        State('store-pink-review', 'data'),
        State('store-red', 'data'),
        State('store-red-review', 'data'),
        State('store-gold', 'data'),
        State('store-gold-review', 'data'),
        State('store-loe', 'data'),
        State('store-virtual-board', 'data')
    ],
    prevent_initial_call=True
)
def handle_doc_upload(contents_lists, filenames_lists,
                     shred, pink, pink_review, red, red_review, gold, gold_review, loe, virtual_board):
    stores = [shred, pink, pink_review, red, red_review, gold, gold_review, loe, virtual_board]
    file_list = []
    doc_names = [None]*9
    progress = dash.no_update

    triggered = callback_context.triggered
    if not triggered or not contents_lists:
        return [dash.no_update]*19 + [dash.no_update]

    subtype_map = {
        "shred": (0, 0),
        "pink": (1, 1),
        "pink_review": (2, 2),
        "red": (3, 3),
        "red_review": (4, 4),
        "gold": (5, 5),
        "gold_review": (6, 6),
        "loe": (7, 7),
        "virtual_board": (8, 8)
    }

    for i, (contents, filenames) in enumerate(zip(contents_lists, filenames_lists)):
        if contents and filenames:
            id_dict = callback_context.inputs_list[0][i]['id']
            subtype = id_dict['subtype']
            idx, doc_name_idx = subtype_map[subtype]
            if isinstance(contents, str):
                contents = [contents]
                filenames = [filenames]
            content = contents[-1]
            name = filenames[-1]
            file_text = process_document(content, name)
            set_uploaded_doc(subtype, file_text, name)
            stores[idx] = file_text
            doc_names[doc_name_idx] = name
            if subtype == "shred":
                file_list = [
                    dbc.Row([
                        dbc.Col(
                            html.Button('×', id={'type': 'remove-file', 'index': name}, style={'marginRight': '5px', 'fontSize': '10px'}),
                            width=1
                        ),
                        dbc.Col(
                            html.Span(name, style={'wordBreak': 'break-all'}),
                            width=11
                        )
                    ], id={'type': 'file-row', 'index': name}, align="center", className="mb-1")
                ]
            progress = "progress"
            break

    return stores + [file_list] + doc_names + [progress]

@app.callback(
    [
        Output('document-preview', 'children'),
        Output('store-generated-doc', 'data'),
        Output('download-document', 'data'),
        Output('progress-dot-store', 'data')
    ],
    [
        Input({'type': 'btn-generate-doc', 'index': ALL}, 'n_clicks'),
        Input("btn-download", "n_clicks"),
        Input('selected-doc-type', 'data')
    ],
    [
        State('store-shred', 'data'),
        State('store-pink', 'data'),
        State('store-pink-review', 'data'),
        State('store-red', 'data'),
        State('store-red-review', 'data'),
        State('store-gold', 'data'),
        State('store-gold-review', 'data'),
        State('store-loe', 'data'),
        State('store-virtual-board', 'data'),
        State('store-generated-doc', 'data')
    ],
    prevent_initial_call=True
)
def handle_preview_generate_download(n_clicks_generate_list, n_clicks_download, selected_type,
                                     shred, pink, pink_review, red, red_review, gold, gold_review, loe, virtual_board, prev_generated):
    ctx = callback_context
    trigger = ctx.triggered[0]['prop_id'] if ctx.triggered else ""
    logging.info(f"Unified preview/generate/download trigger: {trigger}")

    # Download logic
    if "btn-download" in trigger:
        doc = prev_generated
        if not doc:
            doc = get_generated_doc(selected_type)
        if not doc:
            if selected_type == "Shred":
                doc = shred
            elif selected_type == "Pink":
                doc = pink
            elif selected_type == "Pink Review":
                doc = pink_review
            elif selected_type == "Red":
                doc = red
            elif selected_type == "Red Review":
                doc = red_review
            elif selected_type == "Gold":
                doc = gold
            elif selected_type == "Gold Review":
                doc = gold_review
            elif selected_type == "LOE":
                doc = loe
            elif selected_type == "Virtual Board":
                doc = virtual_board
        if not doc:
            logging.warning("No generated document to download.")
            return dash.no_update, dash.no_update, dash.no_update, dash.no_update
        if selected_type in spreadsheet_types:
            xlsx_io = markdown_tables_to_xlsx(doc)
            logging.info("Spreadsheet document prepared for download.")
            return dash.no_update, dash.no_update, dcc.send_bytes(xlsx_io.getvalue(), filename=f"{selected_type}_output.xlsx"), "progress"
        else:
            content = doc.encode('utf-8')
            logging.info("Narrative document prepared for download.")
            return dash.no_update, dash.no_update, dcc.send_bytes(content, filename=f"{selected_type}_output.md"), "progress"

    # Generate logic
    if any(n_clicks_generate_list):
        logging.info(f"Generating document for type: {selected_type}")
        inputs = {
            "shred": shred,
            "pink": pink,
            "pink_review": pink_review,
            "red": red,
            "red_review": red_review,
            "gold": gold,
            "gold_review": gold_review,
            "loe": loe,
            "virtual_board": virtual_board
        }
        prompt = document_types.get(selected_type, "")
        context = ""
        if selected_type in doc_dependencies:
            for dep in doc_dependencies[selected_type]["source"]:
                context += f"\n\n{dep.upper()}:\n{inputs.get(dep, '')}"
        else:
            context += f"\n\n{inputs.get('shred','')}"
        full_prompt = f"{prompt}\n\n{context}"
        result_holder = {}
        def gemini_thread():
            try:
                model = genai.GenerativeModel(GEMINI_MODEL)
                response = model.generate_content(full_prompt, stream=False)
                result_holder['result'] = response.text if hasattr(response, 'text') else str(response)
                logging.info("Gemini document generated successfully.")
            except Exception as e:
                logging.error(f"Error with Gemini API: {str(e)}")
                result_holder['result'] = f"Error generating document: {str(e)}"
        t = threading.Thread(target=gemini_thread)
        t.start()
        t.join(timeout=60)
        generated_doc = result_holder.get('result', 'Error: No document generated.')
        set_generated_doc(selected_type, generated_doc)
        if selected_type in spreadsheet_types:
            preview = markdown_table_preview(generated_doc)
        else:
            preview = markdown_narrative_preview(generated_doc)
        logging.info("Document preview updated.")
        return preview, generated_doc, dash.no_update, "progress"

    # Preview logic (selected type changed)
    doc = get_generated_doc(selected_type)
    if not doc:
        if selected_type == "Shred" and shred:
            return markdown_table_preview(shred), dash.no_update, dash.no_update, dash.no_update
        elif selected_type in spreadsheet_types:
            doc_store = {
                "Pink Review": pink_review,
                "Red Review": red_review,
                "Gold Review": gold_review,
                "Virtual Board": virtual_board,
                "LOE": loe
            }
            doc = doc_store.get(selected_type, "")
            return markdown_table_preview(doc), dash.no_update, dash.no_update, dash.no_update
        elif selected_type in narrative_types:
            doc_store = {
                "Pink": pink,
                "Red": red,
                "Gold": gold
            }
            doc = doc_store.get(selected_type, "")
            return markdown_narrative_preview(doc), dash.no_update, dash.no_update, dash.no_update
        return html.Div("No document loaded."), dash.no_update, dash.no_update, dash.no_update
    if selected_type in spreadsheet_types:
        return markdown_table_preview(doc), doc, dash.no_update, dash.no_update
    else:
        return markdown_narrative_preview(doc), doc, dash.no_update, dash.no_update

@app.callback(
    Output("main-progress-dot-output", "children"),
    Input('progress-dot-store', 'data')
)
def update_main_progress_dot(progress):
    return ""

if __name__ == '__main__':
    print("Starting the Dash application...")
    app.run(debug=True, host='0.0.0.0', port=7860, threaded=True)
    print("Dash application has finished running.")