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

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"

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

uploaded_files = {}
uploaded_doc_contents = {}

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("No table found.")
    tables = extract_markdown_tables(md_text)
    if not tables:
        return html.Div("No table found.")
    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'
                        # autoFocus removed for Dash compatibility
                    ),
                    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.Div([
            html.Div(className="blinking-dot", style={'margin':'0 auto','width':'16px','height':'16px'}),
        ], style={'textAlign':'center', 'marginBottom':'10px'}),
        html.Hr(style={'marginTop': '8px', 'marginBottom': '16px'}),
        html.Div(
            id='doc-type-buttons'
        ),
        chat_card
    ]

def get_right_col_content(selected_type, shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc):
    controls = []
    controls.append(html.Div([
        html.Div(className="blinking-dot", style={'margin':'0 auto','width':'16px','height':'16px'}),
    ], style={'textAlign':'center', 'marginBottom':'10px'}))
    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='upload-document',
                    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([
                    html.Div("Loaded Shred Document:", className="mt-2 mb-1"),
                    markdown_table_preview(shred_doc) if shred_doc else html.Div("No Shred document loaded.")
                ], style={'marginBottom': '12px'})
            ])
        )
    elif selected_type in doc_dependencies:
        sources = doc_dependencies[selected_type]["source"]
        for src in sources:
            label = ""
            loaded_preview = None
            store_var = None
            if src == "shred":
                label = "Shred (Requirements)"
                store_var = shred_doc
                loaded_preview = markdown_table_preview(shred_doc) if shred_doc else html.Div("No Shred document loaded.")
            elif src == "pink":
                label = "Pink Document"
                store_var = pink_doc
                loaded_preview = markdown_narrative_preview(pink_doc) if pink_doc else html.Div("No Pink document loaded.")
            elif src == "pink_review":
                label = "Pink Review"
                store_var = pink_review_doc
                loaded_preview = markdown_table_preview(pink_review_doc) if pink_review_doc else html.Div("No Pink Review document loaded.")
            elif src == "red":
                label = "Red Document"
                store_var = red_doc
                loaded_preview = markdown_narrative_preview(red_doc) if red_doc else html.Div("No Red document loaded.")
            elif src == "red_review":
                label = "Red Review"
                store_var = red_review_doc
                loaded_preview = markdown_table_preview(red_review_doc) if red_review_doc else html.Div("No Red Review document loaded.")
            elif src == "gold":
                label = "Gold Document"
                store_var = gold_doc
                loaded_preview = markdown_narrative_preview(gold_doc) if gold_doc else html.Div("No Gold document loaded.")
            controls.append(html.Div([
                html.Label(f"Upload {label}"),
                dcc.Upload(
                    id={'type': f'upload-doc-type-{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={'type': f'uploaded-doc-name-{src}', 'index': selected_type}),
                dbc.RadioItems(
                    id={'type': f'radio-doc-source-{src}', 'index': selected_type},
                    options=[
                        {'label': 'Loaded Document', 'value': 'loaded'},
                        {'label': 'Uploaded Document', 'value': 'uploaded'}
                    ] if store_var else [{'label': 'Uploaded Document', 'value': 'uploaded'}],
                    value='loaded' if store_var else 'uploaded',
                    inline=True,
                    className="mb-2"
                ),
                html.Div([
                    html.Div("Loaded Document Preview:", className="mt-2 mb-1"),
                    loaded_preview
                ], style={'marginBottom': '12px'}) if store_var else None,
            ], 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.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'),
    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(
            html.Div([
                html.Div(className="blinking-dot", style={'margin':'0 auto','width':'16px','height':'16px'}),
            ], 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'),
    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'),
)
def update_right_col(selected_type, shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc):
    return get_right_col_content(selected_type, shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc)

@app.callback(
    Output('file-list', 'children'),
    Output('store-shred', 'data'),
    Output('document-preview', 'children'),
    Output('loading-output', 'children'),
    Output('store-generated-doc', 'data'),
    Input('upload-document', 'contents'),
    State('upload-document', 'filename'),
    State('file-list', 'children'),
    State('store-shred', 'data'),
    Input({'type': 'btn-generate-doc', 'index': ALL}, 'n_clicks'),
    State('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'),
    prevent_initial_call=True
)
def combined_callback(
    upload_contents, upload_filenames, existing_files, current_shred,
    n_clicks, selected_type, shred, pink, pink_review, red, red_review, gold, gold_review, loe, virtual_board
):
    ctx = callback_context
    trigger = ctx.triggered[0]['prop_id'].split('.')[0] if ctx.triggered else ""
    # Default outputs
    files_display = existing_files if existing_files else []
    new_shred = current_shred
    preview = dash.no_update
    loading_msg = ""
    generated_doc = dash.no_update

    if trigger == "upload-document":
        if upload_contents and upload_filenames:
            for content, name in zip(upload_contents, upload_filenames):
                file_content = process_document(content, name)
                uploaded_files[name] = file_content
                new_shred = file_content
                files_display.append(
                    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")
                )
            logging.info("Shred document uploaded and stored.")
            preview = markdown_table_preview(new_shred)
            generated_doc = dash.no_update
        else:
            preview = markdown_table_preview(new_shred) if new_shred else html.Div("No Shred document loaded.")
            generated_doc = dash.no_update
        return files_display, new_shred, preview, loading_msg, generated_doc

    if any(n_clicks):
        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.')
        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 dash.no_update, dash.no_update, preview, "", generated_doc

    return files_display, new_shred, markdown_table_preview(new_shred) if new_shred else html.Div("No Shred document loaded."), loading_msg, generated_doc

@app.callback(
    Output("download-document", "data"),
    Input("btn-download", "n_clicks"),
    State('selected-doc-type', 'data'),
    State('store-generated-doc', 'data'),
    prevent_initial_call=True
)
def download_document(n_clicks, selected_type, generated_doc):
    if not generated_doc:
        logging.warning("No generated document to download.")
        return dash.no_update
    if selected_type in spreadsheet_types:
        xlsx_io = markdown_tables_to_xlsx(generated_doc)
        logging.info("Spreadsheet document prepared for download.")
        return dcc.send_bytes(xlsx_io.getvalue(), filename=f"{selected_type}_output.xlsx")
    else:
        content = generated_doc.encode('utf-8')
        logging.info("Narrative document prepared for download.")
        return dcc.send_bytes(content, filename=f"{selected_type}_output.md")

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.")