app.py

# -------- app_final.py --------
import os, json, math, pathlib, re, time, logging, requests
import numpy as np
import plotly.graph_objects as go
import gradio as gr
import openai

# ──────────────────────────
# 0. API keys & Brave Search
# ──────────────────────────
if "OPENAI_API_KEY" not in os.environ:
    os.environ["OPENAI_API_KEY"] = input("🔑 Enter your OpenAI API key: ").strip()
openai.api_key = os.environ["OPENAI_API_KEY"]

BRAVE_KEY      = os.getenv("BRAVE_KEY", "")        # Brave Search API Key
BRAVE_ENDPOINT = "https://api.search.brave.com/res/v1/web/search"
logging.basicConfig(level=logging.INFO)

# ──────────────────────────
# 1. Cycle config
# ──────────────────────────
CENTER = 2025
CYCLES = {
    "K-Wave":   50,   # Kondratiev long wave
    "Business":  9,   # Juglar investment cycle
    "Finance":  80,   # Long credit cycle
    "Hegemony": 250   # Power-shift cycle
}
ORDERED_PERIODS = sorted(CYCLES.values())            # [9, 50, 80, 250]
COLOR = {9:"#66ff66", 50:"#ff3333", 80:"#ffcc00", 250:"#66ccff"}
AMPL  = {9:0.6,        50:1.0,      80:1.6,        250:4.0}
PERIOD_BY_CYCLE = {k:v for k,v in CYCLES.items()}

# ──────────────────────────
# 2. Load events JSON
# ──────────────────────────
EVENTS_PATH = pathlib.Path(__file__).with_name("cycle_events.json")
with open(EVENTS_PATH, encoding="utf-8") as f:
    EVENTS = {int(item["year"]): item["events"] for item in json.load(f)}

# ──────────────────────────
# 3. Brave Search helpers
# ──────────────────────────
def brave_search(query: str, count: int = 8):
    """Call Brave Search API; return list of dicts."""
    if not BRAVE_KEY:
        logging.warning("⚠️  BRAVE_KEY is empty; web search disabled.")
        return []
    try:
        hdrs = {
            "Accept": "application/json",
            "X-Subscription-Token": BRAVE_KEY
        }
        data = requests.get(
            BRAVE_ENDPOINT,
            headers=hdrs,
            params={"q": query, "count": str(count)},
            timeout=15
        ).json()
        raw = data.get("web", {}).get("results") or []
        return [
            {
                "title": r.get("title", ""),
                "url":   r.get("url", r.get("link", "")),
                "snippet": r.get("description", r.get("text", "")),
                "host": re.sub(r"https?://(www\.)?", "", r.get("url", "")).split("/")[0]
            }
            for r in raw[:count]
        ]
    except Exception as e:
        logging.error(f"Brave Search Error: {e}")
        return []

def format_search_results(query: str) -> str:
    """Format search results as markdown for LLM context."""
    arts = brave_search(query)
    if not arts:
        return f"# [Web-Search] No live results for “{query}”.\n"
    hdr = f"# [Web-Search] Top results for “{query}”\n\n"
    body = "\n".join(
        f"**{i+1}. {a['title']}** ({a['host']})\n\n"
        f"{a['snippet']}\n\n"
        f"[Source]({a['url']})\n"
        for i, a in enumerate(arts)
    )
    return hdr + body + "\n"

# ──────────────────────────
# 4. Helper functions (chart)
# ──────────────────────────
def half_sine(xs, period, amp):
    """Half-sine ‘tower’ with zero bottom floor."""
    phase = np.mod(xs - CENTER, period)
    y = amp * np.sin(np.pi * phase / period)
    y[y < 0] = 0
    return y

def build_chart(start: int, end: int):
    """Return (Plotly figure, summary string) for the requested year range,
       plus a transparent hover-trace so the cursor always shows ‘Year ####’. """
    xs = np.linspace(start, end, max(1000, (end - start) * 4))
    fig = go.Figure()

    # 1) Gradient half-sine towers
    for period in ORDERED_PERIODS:
        base_amp, color = AMPL[period], COLOR[period]
        for frac in np.linspace(base_amp / 30, base_amp, 30):
            fig.add_trace(go.Scatter(
                x=xs, y=half_sine(xs, period, frac),
                mode="lines",
                line=dict(color=color, width=0.8),
                opacity=0.6,
                hoverinfo="skip", showlegend=False))
        fig.add_trace(go.Scatter(
            x=xs, y=half_sine(xs, period, base_amp),
            mode="lines",
            line=dict(color=color, width=1.6),
            hoverinfo="skip", showlegend=False))

    # 2) Event markers (bilingual hover)
    for year, evs in EVENTS.items():
        if start <= year <= end:
            cyc = evs[0]["cycle"]; period = PERIOD_BY_CYCLE[cyc]
            y_val = float(half_sine(np.array([year]), period, AMPL[period]))
            fig.add_trace(go.Scatter(
                x=[year], y=[y_val], mode="markers",
                marker=dict(color="white", size=6),
                customdata=[[cyc,
                             "<br>".join(e["event_en"] for e in evs),
                             "<br>".join(e["event_ko"] for e in evs)]],
                hovertemplate=(
                    "Year %{x} • %{customdata[0]} cycle"
                    "<br>%{customdata[1]}"
                    "<br>%{customdata[2]}<extra></extra>"
                ),
                showlegend=False))

    # 3) Transparent hover-trace so any x shows ‘Year ####’
    fig.add_trace(go.Scatter(
        x=xs,
        y=np.full_like(xs, -0.05),                 # just below baseline
        mode="lines",
        line=dict(color="rgba(0,0,0,0)", width=1), # invisible
        hovertemplate="Year %{x:.0f}<extra></extra>",
        showlegend=False))

    # 4) Cosmetic touches: centre line & 250-yr arrow
    fig.add_vline(x=CENTER, line_dash="dash", line_color="white", opacity=0.6)
    arrow_y = AMPL[250] * 1.05
    fig.add_annotation(
        x=CENTER-125, y=arrow_y, ax=CENTER+125, ay=arrow_y,
        xref="x", yref="y", axref="x", ayref="y",
        showarrow=True, arrowhead=3, arrowsize=1,
        arrowwidth=1.2, arrowcolor="white")
    fig.add_annotation(
        x=CENTER, y=arrow_y+0.15, text="250 yr",
        showarrow=False, font=dict(color="white", size=10))

    # 5) Layout
    fig.update_layout(
        template="plotly_dark",
        paper_bgcolor="black", plot_bgcolor="black",
        height=450,
        margin=dict(t=30, l=40, r=40, b=40),
        hoverlabel=dict(bgcolor="#222", font_size=11),
        hovermode="x"                               # unified x-hover
    )
    fig.update_xaxes(title="Year",  range=[start, end], showgrid=False)
    fig.update_yaxes(title="Relative amplitude",
                     showticklabels=False, showgrid=False)

    summary = f"Range {start}-{end} | Events plotted: " \
              f"{sum(1 for y in EVENTS if start <= y <= end)}"
    return fig, summary

# ──────────────────────────
# 5. GPT chat helper
# ──────────────────────────
BASE_PROMPT = (
    "당신은 **CycleNavigator AI**로, 경제사·국제정치·장주기(9y Business, 50y K-Wave, "
    "80y Finance, 250y Hegemony) 분석에 정통한 전문가입니다. "
    "모든 답변은 한국어로 하되 학술적 정확성과 실무적 명료성을 동시에 갖추십시오. "
    "✦ 답변 구조 지침: ① 질문 핵심 요약 → ② 4대 주기와의 관련성 명시 → "
    "③ 역사·데이터 근거 설명 → ④ 시사점·전망 순으로 서술하며, "
    "번호‧글머리표·짧은 문단을 활용해 논리적으로 배열합니다. "
    "✦ 제공된 [Chart summary]는 반드시 해석·인용하고, "
    "객관적 사실·연도·사건을 근거로 합니다. "
    "✦ 근거가 불충분할 땐 ‘확실하지 않습니다’라고 명시해 추측을 피하십시오. "
    "✦ 불필요한 장황함은 삼가고 3개 단락 또는 7개 이하 bullets 내로 요약하십시오."
)

def chat_with_gpt(history, user_msg, chart_summary):
    messages = [{"role": "system", "content": BASE_PROMPT}]
    if chart_summary not in ("", "No chart yet."):
        messages.append({"role": "system", "content": f"[Chart summary]\n{chart_summary}"})

    for u, a in history:
        messages.extend([{"role": "user", "content": u},
                         {"role": "assistant", "content": a}])
    messages.append({"role": "user", "content": user_msg})

    res = openai.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=messages,
        max_tokens=600,
        temperature=0.7
    )
    return res.choices[0].message.content.strip()

# ──────────────────────────
# 6. Gradio UI
# ──────────────────────────
def create_app():
    with gr.Blocks(theme=gr.themes.Soft()) as demo:
        # Title & subtitles
        gr.Markdown("## 🔭 **CycleNavigator (Interactive)**")
        gr.Markdown(
            "### <sub>Interactive visual service delivering insights at a glance into "
            "the four major long cycles—9-year business cycle, 50-year Kondratiev wave, "
            "80-year financial credit cycle, and 250-year hegemony cycle—through dynamic "
            "charts and AI chat.</sub>"
        )
        gr.Markdown(
            "<sub>"
            "<b>Business 9y</b> (credit-investment business cycle) • "
            "<b>K-Wave 50y</b> (long technological-industrial wave) • "
            "<b>Finance 80y</b> (long credit-debt cycle) • "
            "<b>Hegemony 250y</b> (rise & fall of global powers cycle)"
            "</sub>"
        )

        chart_summary_state = gr.State(value="No chart yet.")

        with gr.Tabs():
            with gr.TabItem("Timeline Chart"):
    # 1️⃣ 먼저 차트를 만들고 화면에 배치
                fig0, summ0 = build_chart(1500, 2500)
                plot = gr.Plot(value=fig0)                    # ⬆️ 차트가 맨 위에 위치
                chart_summary_state.value = summ0

    # 2️⃣ 차트 아래에 컨트롤(연도 입력 + 줌 버튼) 배치
                with gr.Row():
                    start_year = gr.Number(label="Start Year", value=1500, precision=0)
                    end_year   = gr.Number(label="End Year",   value=2500, precision=0)
                    zoom_in    = gr.Button("🔍 Zoom In")
                    zoom_out   = gr.Button("🔎 Zoom Out")



                def refresh(s, e):
                    fig, summ = build_chart(int(s), int(e))
                    return fig, summ
                start_year.change(refresh, [start_year, end_year],
                                             [plot, chart_summary_state])
                end_year.change(refresh,   [start_year, end_year],
                                             [plot, chart_summary_state])

                def zoom(s, e, factor):
                    mid = (s + e) / 2
                    span = (e - s) * factor / 2
                    ns, ne = int(mid - span), int(mid + span)
                    fig, summ = build_chart(ns, ne)
                    return ns, ne, fig, summ

                zoom_in.click(lambda s, e: zoom(s, e, 0.5),
                              inputs=[start_year, end_year],
                              outputs=[start_year, end_year, plot, chart_summary_state])
                zoom_out.click(lambda s, e: zoom(s, e, 2.0),
                               inputs=[start_year, end_year],
                               outputs=[start_year, end_year, plot, chart_summary_state])

                gr.File(value=str(EVENTS_PATH), label="Download cycle_events.json")

            # ── Tab 2: GPT Chat ──
            with gr.TabItem("Deep Research Chat"):
                chatbot    = gr.Chatbot(label="Assistant")
                user_input = gr.Textbox(lines=3, placeholder="메시지를 입력하세요…")

                with gr.Row():
                    send_btn = gr.Button("Send", variant="primary")
                    web_btn  = gr.Button("🔎 Web Search")  # NEW

                # 기본 답변
                def respond(history, msg, summ):
                    reply = chat_with_gpt(history, msg, summ)
                    history.append((msg, reply))
                    return history, gr.Textbox(value="")

                # 웹 검색 후 답변
                def respond_with_search(history, msg, summ):
                    search_md = format_search_results(msg)
                    combined  = f"{msg}\n\n{search_md}"
                    reply = chat_with_gpt(history, combined, summ)
                    history.append((f"{msg}\n\n(웹검색 실행)", reply))
                    return history, gr.Textbox(value="")

                send_btn.click(respond,
                               [chatbot, user_input, chart_summary_state],
                               [chatbot, user_input])
                user_input.submit(respond,
                                  [chatbot, user_input, chart_summary_state],
                                  [chatbot, user_input])
                web_btn.click(respond_with_search,
                               [chatbot, user_input, chart_summary_state],
                               [chatbot, user_input])
    return demo

# ──────────────────────────
# 7. main
# ──────────────────────────
if __name__ == "__main__":
    create_app().launch()