app.py

import json, os
from io import StringIO
import pandas as pd
import streamlit as st
from snowflake.snowpark import Session
from bs4 import BeautifulSoup
from Messaging_system.Permes import Permes
from dotenv import load_dotenv

from Messaging_system.SnowFlakeConnection import SnowFlakeConn

load_dotenv()


# ──────────────────────────────────────────────────────────────────────────────
# Helpers
# ──────────────────────────────────────────────────────────────────────────────
@st.cache_data
def load_data(buf) -> pd.DataFrame:
    return pd.read_csv(buf)

def load_config_(file_path: str) -> dict:
    with open(file_path) as f:
        return json.load(f)

def get_credential(key):
    return os.getenv(key) or st.secrets.get(key)



# Authorized emails
AUTHORIZED_EMAILS = {
    "danial@musora.com",
    "danial.ebrat@gmail.com",
    "simon@musora.com",
    "una@musora.com",
    "mark@musora.com",
    "gabriel@musora.com",
    "nikki@musora.com"
}


# --- one env var that holds the shared password / token ---------------------
VALID_TOKEN = get_credential("APP_TOKEN")

# --- small utility -----------------------------------------------------------
def verify_login(email: str, token: str) -> bool:
    """True ⇢ both the address and the token are valid."""
    return (email.lower().strip() in AUTHORIZED_EMAILS) and (token == VALID_TOKEN)

# --- UI: show a form until the user is authenticated ------------------------
if not st.session_state.get("authenticated", False):

    st.title("🔐 Sign-in")
    st.markdown(
        "Access is limited to authorised users. "
        "Enter your **e-mail** and the shared **access token**."
    )

    with st.form("login"):
        email = st.text_input("e-mail")
        token = st.text_input("access token", type="password")
        submitted = st.form_submit_button("Log in")

    if submitted:
        if verify_login(email, token):
            st.session_state.authenticated = True
            st.session_state.user_email = email
            st.success("Login successful – redirecting…")
            st.rerun()        # reloads the app, now “inside”
        else:
            st.error("⛔ Invalid e-mail or token")

    # IMPORTANT: stop executing the rest of the app while not logged-in
    st.stop()




def init_state() -> None:
    defaults = dict(
        involve_recsys_result=False, personalization=False,
        involve_last_interaction=False, session=None,
        valid_instructions="",
        invalid_instructions="",
        messaging_type="push",
        generated=False, model=None,
        include_recommendation=False,
        data=None, brand=None, recsys_contents=[], csv_output=None,
        users_message=None, messaging_mode=None, target_column=None,
        ugc_column=None, identifier_column=None, input_validator=None,
        selected_input_features=None, selected_features=None,
        additional_instructions=None, segment_info="", message_style="",
        sample_example="", CTA="", all_features=None, number_of_messages=1,
        instructionset={}, subsequent_examples={}, segment_name="", number_of_samples=10,
        selected_source_features=[], platform=None, generate_clicked=False, config=None,
    )
    for k, v in defaults.items():
        st.session_state.setdefault(k, v)

# ──────────────────────────────────────────────────────────────────────────────
# PAGE CONFIG + THEME
# ──────────────────────────────────────────────────────────────────────────────
st.set_page_config(
    page_title="Personalized Message Generator",
    page_icon="📬",
    layout="wide",
    initial_sidebar_state="expanded"
)

st.markdown(
    """
    <style>
    html, body, [class*="css"]  {
        background-color:#0d0d0d;
        color:#ffd700;
    }
    .stButton>button, .stDownloadButton>button {
        border-radius:8px;
        background:#ffd700;
        color:#0d0d0d;
        font-weight:600;
    }
    .stTabs [data-baseweb="tab"] {
        font-weight:600;
    }
    .stTabs [aria-selected="true"] {
        color:#ffd700;
    }
    h1, h2, h3 {color:#ffd700;}
    .small {font-size:0.85rem; opacity:0.7;}
    </style>
    """,
    unsafe_allow_html=True
)

# ──────────────────────────────────────────────────────────────────────────────
#  SIDEBAR  –  the “control panel”
# ──────────────────────────────────────────────────────────────────────────────
init_state()
with st.sidebar:

    # ─ Brand
    st.selectbox(
        "Select a Brand to Start! *",
        ["drumeo", "pianote", "guitareo", "singeo"],
        key="brand",
    )

    if st.session_state.brand is not None and st.session_state.session is None:
        # ─ build Snowflake session
        conn = dict(
            user=get_credential("snowflake_user"),
            password=get_credential("snowflake_password"),
            account=get_credential("snowflake_account"),
            role=get_credential("snowflake_role"),
            database=get_credential("snowflake_database"),
            warehouse=get_credential("snowflake_warehouse"),
            schema=get_credential("snowflake_schema")
        )
        st.session_state.session = Session.builder.configs(conn).create()

        snowflake = SnowFlakeConn(session=st.session_state.session, brand=st.session_state.brand)
        st.session_state.data = snowflake.get_inactive_users_by_brand(brand=st.session_state.brand)
        st.success("File loaded!")

        st.markdown("---")

    if st.session_state.data is not None:
        id_col = "email"
        st.session_state.identifier_column = id_col

        st.session_state.config = load_config_("Config_files/message_system_config.json")

        # ─ Brand
        st.selectbox(
            "LLM model *",
            st.session_state.config["LLM_models"],
            key="model"
        )

        # ─ Personalization
        st.text_area("Segment info *", key="segment_info")
        st.checkbox("Modify examples to make the message personalized", key="personalization")

        # ─ RecSys
        st.checkbox("Include recommendation", key="include_recommendation")
        if st.session_state.include_recommendation:
            st.multiselect(
                "Recommendation types",
                ["song", "workout", "quick_tips", "course"],
                key="recsys_contents"
            )


        st.text_area("Examples", key="sample_example",
                         placeholder="Provide examples: The LLM will pick from the options and personalize it for the user.")
        st.number_input("Number of samples (default = 10)", 1, 50,
                        key="number_of_samples")

        # ─ Sequential messages
        st.number_input("Sequential messages / user", 1, 12, 1,
                        key="number_of_messages")
        st.text_input("Segment name", key="segment_name",
                      placeholder="no_recent_activity")
        if st.session_state.number_of_messages > 1:
            st.caption("Additional per-message instructions")
            for i in range(2, st.session_state.number_of_messages + 1):
                # st.text_area(f"Message {i} instruction",
                #               key=f"instr_{i}")

                st.text_area(f"Examples for message #{i}",
                               key=f"ex_{i}",
                               placeholder="e.g. \"Hey {name}! We miss you – open the app to …\"")


        st.markdown("---")

        if st.button("🚀 Generate messages", key="generate"):
            st.session_state.generate_clicked = True  # ask for a new run
            st.session_state.generated = False  # forget old results


# ──────────────────────────────────────────────────────────────────────────────
#  MAIN AREA  –  three tabs
# ──────────────────────────────────────────────────────────────────────────────
tab0, tab2 = st.tabs(
    ["📊 Data preview", "📨 Results"])

# ------------------------------------------------------------------ TAB 0 ---#
with tab0:
    st.header("📊 Data preview")
    if st.session_state.data is not None:
        st.dataframe(st.session_state.data.head(100))
    else:
        st.info("Select a brand to preview the data here.")


# ------------------------------------------------------------------ TAB 2 ---#
with tab2:
    st.header("📨 Generated messages")
    # Run generation only once per click
    if st.session_state.generate_clicked and not st.session_state.generated:

        if st.session_state.get("generate_clicked", False):

            # ─ prepare parameters
            st.session_state.messaging_mode = (
                "recsys_result" if st.session_state.include_recommendation
                else "message"
            )
            st.session_state.involve_recsys_result = st.session_state.include_recommendation

            st.session_state.instructionset = {
                i: st.session_state.get(f"instr_{i}")
                for i in range(2, st.session_state.number_of_messages + 1)
                if st.session_state.get(f"instr_{i}", "").strip()
            }

            st.session_state.subsequent_examples = {
                i: st.session_state.get(f"ex_{i}")
                for i in range(2, st.session_state.number_of_messages + 1)
                if st.session_state.get(f"ex_{i}", "").strip()
            }


            # ─ progress callback
            prog = st.progress(0)
            status = st.empty()

            def cb(done, total):
                pct = int(done / total * 100)
                prog.progress(pct)
                status.write(f"{pct}%")

            permes = Permes()
            df_msg = permes.create_personalize_messages(
                session=st.session_state.session,
                users=st.session_state.data,
                brand=st.session_state.brand,
                segment_info=st.session_state.segment_info,
                config_file=st.session_state.config,
                openai_api_key=get_credential("OPENAI_API"),
                model=st.session_state.model,
                number_of_samples=st.session_state.number_of_samples,
                sample_example=st.session_state.sample_example,
                platform=st.session_state.messaging_type,
                involve_recsys_result=st.session_state.involve_recsys_result,
                messaging_mode=st.session_state.messaging_mode,
                identifier_column=st.session_state.identifier_column,
                recsys_contents=st.session_state.recsys_contents,
                progress_callback=cb,
                number_of_messages=st.session_state.number_of_messages,
                instructionset=st.session_state.instructionset,
                subsequent_examples = st.session_state.subsequent_examples,
                segment_name=st.session_state.segment_name,
                personalization=st.session_state.personalization
            )

            if df_msg is None:
                st.write("##### 👤 There were no eligible user to generate messages. Consider setting higher number of users.")


            # ─ cache output
            st.session_state.users_message = df_msg
            st.session_state.csv_output = df_msg.to_csv(
                index=False, encoding="utf-8-sig")
            st.session_state.generated = True
            st.session_state.generate_clicked = False
            prog.empty(); status.empty()
            st.balloons()

    # =============================================================
    if st.session_state.get("generated", False):
        df = st.session_state.users_message
        id_col = st.session_state.identifier_column or ""
        id_col_lower = id_col.lower()

        # expandable per-user cards
        for i, (_, row) in enumerate(df.iterrows(), start=1):
            user_id = row.get(id_col_lower, "(no ID)")
            with st.expander(f"{i}. User ID: {user_id}", expanded=(i == 1)):
                # --- Features
                st.write("##### 👤 Features")
                feats = st.session_state.selected_source_features or []
                cols = st.columns(3)
                for idx, feature in enumerate(feats):
                    val = row.get(feature, "—")
                    cols[idx % 3].markdown(f"**{feature}**: {val}")

                st.markdown("---")

                # --- Messages
                st.write("##### ✉️ Messages")
                raw = row.get("message", "")
                # try to parse JSON if it's a str
                if isinstance(raw, str):
                    try:
                        blob = json.loads(raw)
                    except json.JSONDecodeError:
                        st.error(f"Could not parse JSON for user {user_id}")
                        continue
                elif isinstance(raw, dict) or isinstance(raw, list):
                    blob = raw
                else:
                    blob = {}

                # extract sequence
                if isinstance(blob, dict):
                    seq = blob.get("messages_sequence", [])
                elif isinstance(blob, list):
                    seq = blob
                else:
                    seq = []

                # make sure it's a list
                if not isinstance(seq, list):
                    seq = [seq]

                # render each message
                for j, msg in enumerate(seq, start=1):
                    if not isinstance(msg, dict):
                        # if it's just a string or number, render it plainly
                        st.markdown(f"**{j}. (no header)**")
                        st.markdown(str(msg))
                        st.markdown("---")
                        continue

                    header = msg.get("header", "(no header)")
                    st.markdown(f"**{j}. {header}**")

                    # optional title
                    title = msg.get("title")
                    if title:
                        st.markdown(f"**Title:** {title}")

                    # thumbnail (per-message or fallback per-user)
                    thumb = msg.get("thumbnail_url") or row.get("thumbnail_url")
                    if thumb:
                        st.image(thumb, width=150)

                    # the main message body
                    body = msg.get("message", "")
                    st.markdown(body)

                    # optional "read more" link
                    url = msg.get("web_url_path")
                    if url:
                        st.markdown(f"[Read more]({url})")

                    st.markdown("---")