import os
from openai import OpenAI
import gradio as gr

# Set up OpenAI client
client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

# Initialize conversation history and difficulty
conversation_history = []
current_difficulty = "sedang"

# Predefined scenarios
predefined_scenarios = {
    "Pilih skenario": "",
    "Produk Cacat": "Saya baru saja membeli sebuah produk dari toko Anda, dan ternyata produk tersebut cacat.",
    "Pengiriman Terlambat": "Saya memesan produk minggu lalu dan seharusnya sudah diterima kemarin, tapi belum sampai.",
    "Harga Tidak Sesuai": "Harga yang tertera di rak berbeda dengan yang di kasir saat saya membayar.",
    "Pelayanan Buruk": "Saya tidak puas dengan pelayanan yang saya terima dari salah satu staf Anda.",
    "Pengembalian Barang": "Saya ingin mengembalikan produk yang saya beli, tapi kasir menolak permintaan saya."
}

def get_system_message(difficulty):
    base_message = """
Anda adalah asisten AI yang dirancang untuk mensimulasikan pelanggan dalam skenario pelatihan penjualan asuransi.
Peran Anda HANYA untuk berperan sebagai pelanggan dengan keluhan. JANGAN PERNAH merespons seolah-olah Anda adalah perwakilan penjualan.
Manusia yang berinteraksi dengan Anda akan berperan sebagai perwakilan penjualan asuransi.
Evaluasi respons perwakilan dan putuskan apakah akan melanjutkan percakapan atau mengakhirinya.
Jika perwakilan menangani keluhan Anda dengan baik, tanggapi secara positif sebagai pelanggan yang puas.
Jika perwakilan gagal mengatasi kekhawatiran Anda dengan memadai, tanggapi secara negatif dan tunjukkan bahwa Anda ingin mengakhiri percakapan.
Selalu tetap berperan sebagai pelanggan sepanjang percakapan.
Gunakan Bahasa Indonesia dalam semua respons Anda.
"""
    difficulty_adjustments = {
        "mudah": "Jadilah pelanggan yang mudah diatur, terbuka terhadap saran, dan cepat menerima solusi yang masuk akal.",
        "sedang": "Jadilah pelanggan yang cukup menantang, membutuhkan sedikit bujukan tetapi akhirnya menerima solusi yang baik.",
        "sulit": "Jadilah pelanggan yang sulit, skeptis terhadap solusi dan membutuhkan layanan luar biasa untuk merasa puas."
    }
    return base_message + difficulty_adjustments[difficulty]

def chat_with_gpt(user_message, history):
    global conversation_history
    try:
        conversation_history.append({"role": "user", "content": user_message})
        messages = [
            {"role": "system", "content": get_system_message(current_difficulty)},
            *conversation_history
        ]
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            max_tokens=300
        )
        bot_response = response.choices[0].message.content.strip()
        
        if "sebagai perwakilan penjualan" in bot_response.lower() or "saya bisa membantu anda dengan itu" in bot_response.lower():
            bot_response = "Maaf, tapi saya adalah pelanggan dalam skenario ini. Bisakah Anda menangani keluhan saya?"
        
        conversation_history.append({"role": "assistant", "content": bot_response})
        conversation_ended = "percakapan berakhir" in bot_response.lower() or "mengakhiri" in bot_response.lower()
        history.append((user_message, bot_response))
        if conversation_ended:
            summary_feedback = generate_summary_feedback()
            return history, history, "", summary_feedback
        return history, history, "", None
    except Exception as e:
        error_msg = f"Terjadi kesalahan dalam chat_with_gpt: {str(e)}"
        print(error_msg)
        return history + [("Error", error_msg)], history + [("Error", error_msg)], "", None

def generate_summary_feedback():
    try:
        summary_prompt = "Rangkum percakapan, evaluasi kinerja perwakilan penjualan, dan berikan umpan balik untuk perbaikan. Buat ringkas namun komprehensif."
        messages = [
            {"role": "system", "content": "Anda adalah asisten AI yang memberikan umpan balik tentang interaksi penjualan Asuransi."},
            *conversation_history,
            {"role": "user", "content": summary_prompt}
        ]
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            max_tokens=1000
        )
        return "Status: Selesai\n\n" + response.choices[0].message.content.strip()
    except Exception as e:
        return f"Kesalahan dalam menghasilkan ringkasan: {str(e)}"

def clear_conversation():
    global conversation_history
    conversation_history = []
    return None, None, "", None

def start_new_conversation(difficulty, scenario):
    global current_difficulty, conversation_history
    current_difficulty = difficulty
    try:
        clear_conversation()
        system_message = get_system_message(difficulty)
        initial_prompt = f"Anda adalah pelanggan dengan keluhan berikut: {scenario}. Mulailah percakapan dengan menyampaikan keluhan ini kepada perwakilan penjualan."
        
        conversation_history = [
            {"role": "system", "content": system_message},
            {"role": "user", "content": initial_prompt}
        ]
        
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=conversation_history,
            max_tokens=1500
        )
        initial_response = response.choices[0].message.content.strip()
        conversation_history.append({"role": "assistant", "content": initial_response})
        
        return [(None, initial_response)], [(None, initial_response)], "", None
    except Exception as e:
        error_msg = f"Terjadi kesalahan dalam memulai percakapan baru: {str(e)}"
        print(error_msg)
        return [("Error", error_msg)], [("Error", error_msg)], "", None

def end_conversation(history):
    global conversation_history
    conversation_history.append({"role": "user", "content": "Perwakilan penjualan telah mengakhiri percakapan."})
    summary_feedback = generate_summary_feedback()
    history.append((None, "Perwakilan penjualan telah mengakhiri percakapan."))
    return history, history, "", summary_feedback

def update_scenario(choice):
    return predefined_scenarios[choice]

# Set up Gradio interface
with gr.Blocks() as demo:
    gr.Markdown("# BAWANA AI - Complain Handling Simulator")
    gr.Markdown("Pilih tingkat kesulitan, pilih atau modifikasi skenario, dan mulai simulasi. Anda akan berperan sebagai perwakilan penjualan.")

    difficulty_radio = gr.Radio(["mudah", "sedang", "sulit"], label="Tingkat Kesulitan Pelanggan", value="sedang")
    scenario_dropdown = gr.Dropdown(choices=list(predefined_scenarios.keys()), label="Pilih Skenario", value="Pilih skenario")
    scenario_input = gr.Textbox(label="Skenario Keluhan Pelanggan (Anda dapat memodifikasi)", lines=3)
    new_scenario = gr.Button("Mulai Simulasi")

    chatbot = gr.Chatbot()
    msg = gr.Textbox(label="Respons Anda sebagai perwakilan penjualan")
    with gr.Row():
        submit_btn = gr.Button("Kirim")
        end_btn = gr.Button("Akhiri Percakapan")

    summary = gr.Textbox(label="Ringkasan Percakapan dan Umpan Balik", lines=10, interactive=False)
    clear = gr.Button("Bersihkan Percakapan")

    scenario_dropdown.change(update_scenario, inputs=[scenario_dropdown], outputs=[scenario_input])
    new_scenario.click(start_new_conversation, inputs=[difficulty_radio, scenario_input], outputs=[chatbot, chatbot, msg, summary])
    submit_btn.click(chat_with_gpt, [msg, chatbot], [chatbot, chatbot, msg, summary])
    msg.submit(chat_with_gpt, [msg, chatbot], [chatbot, chatbot, msg, summary])
    end_btn.click(end_conversation, inputs=[chatbot], outputs=[chatbot, chatbot, msg, summary])
    clear.click(clear_conversation, inputs=None, outputs=[chatbot, msg, msg, summary])

# Launch the interface
demo.launch()