app.py

import dash
from dash import dcc, html, Input, Output, State, callback, ALL
import dash_bootstrap_components as dbc
import base64
import io
import pandas as pd
import openai
import os
import time
import uuid
import threading
import tempfile
import shutil
import logging
from flask import request
from dash.exceptions import PreventUpdate
import PyPDF2
import docx
import chardet

# --- Logging Setup ---
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("maiko_matrix_app")

# --- App and Session Setup ---
app = dash.Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP])
server = app.server

openai.api_key = os.environ.get('OPENAI_API_KEY')

# Session management globals
SESSION_DATA = {}
SESSION_LOCKS = {}

def get_session_id():
    if 'session-id' in request.cookies:
        return request.cookies['session-id']
    # Generate new session id (uuid4) if not present
    session_id = str(uuid.uuid4())
    logger.info(f"Generated new session id: {session_id}")
    return session_id

def get_session_data():
    session_id = get_session_id()
    if session_id not in SESSION_DATA:
        SESSION_DATA[session_id] = {
            'uploaded_files': {},  # filename -> temp file path
            'file_texts': {},      # filename -> extracted text
            'current_matrix': None,
            'matrix_type': None,
            'temp_dir': tempfile.mkdtemp(prefix=f"maiko_{session_id}_"),
        }
        SESSION_LOCKS[session_id] = threading.Lock()
    return SESSION_DATA[session_id], SESSION_LOCKS[session_id]

def cleanup_session_tempdirs():
    # Called optionally on server shutdown for cleanup
    for sess in SESSION_DATA.values():
        try:
            shutil.rmtree(sess['temp_dir'])
        except Exception as e:
            logger.warning(f"Failed to cleanup tempdir: {e}")

matrix_types = {
    "Project Deliverables Matrix": "Generate a project deliverables matrix all presumed and actual deliverables based on tasks, requirements and scope.",
    "Communications Plan Matrix": "Create a matrix showing stakeholders, communication methods, frequency, and responsibilities.",
    "Project Kick-off Matrix": "Generate a matrix outlining key project details, goals, team roles, and initial timelines.",
    "Decision Matrix": "Develop a matrix for evaluating options against criteria, with weighted scores analysis of alternatives style.",
    "Lessons Learned Matrix": "Create a matrix capturing project experiences, challenges, solutions, and recommendations.",
    "Key Performance Indicator Matrix": "Generate a matrix of KPIs, their measurable targets, actual performance, and status.",
    "Prioritization Matrix": "Develop a matrix for ranking tasks or features based on importance and urgency.",
    "Risk Matrix": "Create a matrix identifying tasks with potential risks, their likelihood, impact, and mitigation strategies.",
    "RACI Matrix": "Generate a matrix showing team members and their roles (Responsible, Accountable, Consulted, Informed) for each task.",
    "Project Schedule Matrix": "Develop a matrix showing project phases, tasks, durations, and dependencies.",
    "Quality Control Matrix": "Create a matrix outlining measurable quality standards, testing methods, and acceptance criteria.",
    "Requirements Traceability Matrix": "Generate a matrix linking requirements to their sources, test cases, and status.",
    "Sprint Planning Matrix": "Develop a matrix for sprint nubmer, sprint tasks in that sprint number, story points, assignees, and status.",
    "Test Traceability Matrix": "Create a matrix linking test cases to requirements, execution status, and results.",
    "Sprint Backlog": "Generate a matrix of user stories, tasks, estimates, and priorities for the sprint.",
    "Sprint Retrospective": "Develop a matrix capturing what went well, what didn't, and action items from the sprint.",
    "SWOT Matrix": "Create a matrix analyzing Strengths, Weaknesses, Opportunities, and Threats."
}

# --- UI Layout ---
app.layout = dbc.Container([
    dbc.Row([
        dbc.Col([
            dbc.Card([
                dbc.CardBody([
                    html.H4("Project Artifacts", className="mb-3 mt-1"),
                    dcc.Upload(
                        id='upload-files',
                        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
                    ),
                    html.Div(id='file-list'),
                    html.Hr(),
                    html.Div([
                        dbc.Button(
                            matrix_label,
                            id={'type': 'matrix-btn', 'index': matrix_label},
                            color="link",
                            className="mb-2 w-100 text-left custom-button",
                            style={'overflow': 'hidden', 'text-overflow': 'ellipsis', 'white-space': 'nowrap'}
                        ) for matrix_label in matrix_types.keys()
                    ])
                ])
            ], className="mb-2")
        ], width=3, style={'minWidth': '260px', 'background': '#f8f9fa', 'height': '100vh', 'position': 'fixed', 'overflowY': 'auto'}),
        dbc.Col([
            dbc.Row([
                dbc.Col([
                    html.H2("Maiko Project Matrix Generator", className="mb-3 mt-2")
                ])
            ]),
            dbc.Row([
                dbc.Col([
                    dbc.Card([
                        dbc.CardBody([
                            dcc.Loading(
                                id="loading",
                                type="default",
                                children=[
                                    html.Div(id="loading-output"),
                                    html.Div(id='matrix-preview', className="border p-3 mb-3"),
                                    dbc.Button("Download Matrix", id="btn-download", color="success", className="mt-3"),
                                    dcc.Download(id="download-matrix"),
                                ]
                            )
                        ])
                    ])
                ])
            ]),
            html.Hr(),
            dbc.Row([
                dbc.Col([
                    dbc.Card([
                        dbc.CardBody([
                            dcc.Loading(
                                id="chat-loading",
                                type="default",
                                children=[
                                    dbc.Textarea(id="chat-input", placeholder="Chat with Maiko to update matrix...", className="mb-2", style={'width': '100%', 'wordWrap': 'break-word'}),
                                    dbc.Button("Send", id="btn-send-chat", color="primary", className="mb-3"),
                                    html.Div(id="chat-output")
                                ]
                            )
                        ])
                    ])
                ])
            ])
        ], width=9, style={'marginLeft': '30%'})
    ])
], fluid=True, style={'padding': '0'})


# --- File Parsing ---
def parse_file_content(file_path, filename):
    try:
        with open(file_path, "rb") as f:
            decoded = f.read()
        if filename.endswith('.pdf'):
            with io.BytesIO(decoded) as pdf_file:
                reader = PyPDF2.PdfReader(pdf_file)
                return ' '.join([page.extract_text() or "" for page in reader.pages])
        elif filename.endswith('.docx'):
            with io.BytesIO(decoded) as docx_file:
                doc = docx.Document(docx_file)
                return ' '.join([para.text for para in doc.paragraphs])
        elif filename.endswith('.txt') or filename.endswith('.rtf'):
            encoding = chardet.detect(decoded)['encoding']
            return decoded.decode(encoding)
        else:
            return "Unsupported file format"
    except Exception as e:
        logger.exception(f"Error processing file {filename}: {str(e)}")
        return "Error processing file"

def truncate_filename(filename, max_length=24):
    if len(filename) <= max_length:
        return filename
    else:
        return filename[:max_length - 3] + '...'

def get_file_cards(file_dict):
    cards = []
    for name in file_dict:
        cards.append(
            dbc.Card(
                dbc.CardBody(
                    dbc.Row([
                        dbc.Col(
                            html.Span(
                                truncate_filename(name),
                                title=name,
                                style={
                                    'display': 'inline-block',
                                    'overflow': 'hidden',
                                    'textOverflow': 'ellipsis',
                                    'whiteSpace': 'nowrap',
                                    'maxWidth': '90%',
                                    'verticalAlign': 'middle',
                                }
                            ),
                            width='auto',
                            style={'display': 'flex', 'alignItems': 'center', 'padding': '0'}
                        ),
                        dbc.Col(
                            dbc.Button(
                                "Delete",
                                id={'type': 'remove-file', 'index': name},
                                color="danger",
                                size="sm",
                                style={'marginLeft': 'auto', 'float': 'right'}
                            ),
                            width='auto',
                            style={'display': 'flex', 'alignItems': 'center', 'justifyContent': 'flex-end', 'padding': '0'}
                        ),
                    ],
                    justify="between",
                    align="center",
                    style={"margin": "0", "padding": "0"}
                    ),
                    style={'padding': '6px 8px', 'margin': '0', 'display': 'flex', 'alignItems': 'center', 'background': 'none', 'boxShadow': 'none'}
                ),
                style={'border': 'none', 'boxShadow': 'none', 'background': 'none', 'marginBottom': '2px'}
            )
        )
    return cards

# --- Callbacks ---

@app.callback(
    Output('file-list', 'children'),
    Input('upload-files', 'contents'),
    State('upload-files', 'filename'),
    prevent_initial_call=True
)
def update_output(list_of_contents, list_of_names):
    session_data, lock = get_session_data()
    logger.info("Uploading files...")
    if list_of_contents is not None:
        with lock:
            for content, name in zip(list_of_contents, list_of_names):
                content_type, content_string = content.split(',')
                decoded = base64.b64decode(content_string)
                temp_path = os.path.join(session_data['temp_dir'], name)
                with open(temp_path, 'wb') as f:
                    f.write(decoded)
                session_data['uploaded_files'][name] = temp_path
                session_data['file_texts'][name] = parse_file_content(temp_path, name)
            logger.info(f"Files after upload: {list(session_data['uploaded_files'].keys())}")
        return get_file_cards(session_data['uploaded_files'])
    raise PreventUpdate

@app.callback(
    Output('file-list', 'children', allow_duplicate=True),
    Input({'type': 'remove-file', 'index': ALL}, 'n_clicks'),
    State('file-list', 'children'),
    prevent_initial_call=True
)
def remove_file(n_clicks, existing_cards):
    session_data, lock = get_session_data()
    ctx = dash.callback_context
    if not ctx.triggered:
        raise PreventUpdate
    triggered_id = ctx.triggered[0]['prop_id'].split('.')[0]
    import ast
    try:
        triggered_id_dict = ast.literal_eval(triggered_id)
        removed_file = triggered_id_dict['index']
    except Exception:
        raise PreventUpdate
    with lock:
        if removed_file in session_data['uploaded_files']:
            try:
                os.remove(session_data['uploaded_files'][removed_file])
            except Exception as e:
                logger.warning(f"Failed to delete temp file {removed_file}: {e}")
            session_data['uploaded_files'].pop(removed_file, None)
            session_data['file_texts'].pop(removed_file, None)
        logger.info(f"Files after deletion: {list(session_data['uploaded_files'].keys())}")
    return get_file_cards(session_data['uploaded_files'])

@app.callback(
    Output('matrix-preview', 'children'),
    Output('loading-output', 'children'),
    [Input({'type': 'matrix-btn', 'index': matrix_label}, 'n_clicks') for matrix_label in matrix_types.keys()],
    prevent_initial_call=True
)
def generate_matrix(*args):
    session_data, lock = get_session_data()
    ctx = dash.callback_context
    if not ctx.triggered:
        raise PreventUpdate
    button_id = ctx.triggered[0]['prop_id'].split('.')[0]
    import ast
    try:
        triggered = ast.literal_eval(button_id)
        matrix_type = triggered['index']
    except Exception:
        raise PreventUpdate

    if not session_data['uploaded_files']:
        return html.Div("Please upload project artifacts before generating a matrix."), ""
    file_contents = list(session_data['file_texts'].values())
    with lock:
        try:
            session_data['matrix_type'] = matrix_type
            session_data['current_matrix'] = generate_matrix_with_gpt(matrix_type, file_contents)
            logger.info(f"{matrix_type} generated for session.")
            return dbc.Table.from_dataframe(session_data['current_matrix'], striped=True, bordered=True, hover=True), f"{matrix_type} generated"
        except Exception as e:
            logger.exception(f"Error generating matrix: {str(e)}")
            return html.Div(f"Error generating matrix: {str(e)}"), "Error"

def generate_matrix_with_gpt(matrix_type, file_contents):
    prompt = f"""Generate a {matrix_type} based on the following project artifacts:
{' '.join(file_contents)}
Instructions:
1. Create the {matrix_type} as a table.
2. Use ONLY pipe symbols (|) to separate columns.
3. Do NOT include any introductory text, descriptions, or explanations.
4. Do NOT use any dashes (-) or other formatting characters.
5. The first row should be the column headers.
6. Start the output immediately with the column headers.
7. Each subsequent row should represent a single item in the matrix.
Example format:
Header1|Header2|Header3
Item1A|Item1B|Item1C
Item2A|Item2B|Item2C
Now, generate the {matrix_type}:
"""
    response = openai.ChatCompletion.create(
        model="gpt-4-turbo",
        messages=[
            {"role": "system", "content": "You are a precise matrix generator that outputs only the requested matrix without any additional text. Based on the files uploaded, as the project manager you perform the analysis and make appropriate assumptions to populate the matrix like roles, tasks, timelines, logically sequencing the matrix etc."},
            {"role": "user", "content": prompt}
        ]
    )
    matrix_text = response.choices[0].message.content.strip()
    logger.info(f"Raw matrix text from GPT: {matrix_text[:200]}...")  # log only first 200 chars
    lines = [line.strip() for line in matrix_text.split('\n') if '|' in line]
    data = [line.split('|') for line in lines]
    data = [[cell.strip() for cell in row] for row in data]
    headers = data[0]
    data = data[1:]
    return pd.DataFrame(data, columns=headers)

@app.callback(
    Output('chat-output', 'children'),
    Output('matrix-preview', 'children', allow_duplicate=True),
    Input('btn-send-chat', 'n_clicks'),
    State('chat-input', 'value'),
    prevent_initial_call=True
)
def update_matrix_via_chat(n_clicks, chat_input):
    session_data, lock = get_session_data()
    if not chat_input or session_data['current_matrix'] is None or session_data['matrix_type'] is None:
        raise PreventUpdate
    matrix_type = session_data['matrix_type']
    with lock:
        prompt = f"""Update the following {matrix_type} based on this instruction: {chat_input}
Current matrix:
{session_data['current_matrix'].to_string(index=False)}
Instructions:
1. Provide ONLY the updated matrix as a table.
2. Use ONLY pipe symbols (|) to separate columns.
3. Do NOT include any introductory text, descriptions, or explanations.
4. Do NOT use any dashes (-) or other formatting characters.
5. The first row should be the column headers.
6. Start the output immediately with the column headers.
7. Each subsequent row should represent a single item in the matrix.
Now, provide the updated {matrix_type}:
"""
        response = openai.ChatCompletion.create(
            model="gpt-4-turbo",
            messages=[
                {"role": "system", "content": "You are a precise matrix updater that outputs only the requested matrix without any additional text. You will make assumptions as a project manager to produce the matrix based on the limited information provided"},
                {"role": "user", "content": prompt}
            ]
        )
        updated_matrix_text = response.choices[0].message.content.strip()
        logger.info(f"Raw updated matrix text from GPT: {updated_matrix_text[:200]}...")
        lines = [line.strip() for line in updated_matrix_text.split('\n') if '|' in line]
        data = [line.split('|') for line in lines]
        data = [[cell.strip() for cell in row] for row in data]
        headers = data[0]
        data = data[1:]
        session_data['current_matrix'] = pd.DataFrame(data, columns=headers)
        return f"Matrix updated based on: {chat_input}", dbc.Table.from_dataframe(session_data['current_matrix'], striped=True, bordered=True, hover=True)

@app.callback(
    Output("download-matrix", "data"),
    Input("btn-download", "n_clicks"),
    prevent_initial_call=True
)
def download_matrix(n_clicks):
    session_data, lock = get_session_data()
    if session_data['current_matrix'] is None or session_data['matrix_type'] is None:
        raise PreventUpdate
    output = io.BytesIO()
    with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
        session_data['current_matrix'].to_excel(writer, sheet_name='Sheet1', index=False)
    logger.info(f"Matrix downloaded: {session_data['matrix_type']}")
    return dcc.send_bytes(output.getvalue(), f"{session_data['matrix_type']}.xlsx")

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