"""
OpenAI Embedding 기반 독창성 측정 (Gradio GUI)

사용법:
    pip install gradio openai numpy nltk
    python OpenAI_Originality_GUI.py
"""

import numpy as np
import gradio as gr
from openai import OpenAI
from nltk.tokenize import sent_tokenize, word_tokenize
import nltk

# NLTK 데이터 다운로드
try:
    nltk.data.find('tokenizers/punkt_tab')
except LookupError:
    nltk.download('punkt_tab')


def cosine_distance(v1, v2):
    dot = np.dot(v1, v2)
    norm = np.linalg.norm(v1) * np.linalg.norm(v2)
    similarity = dot / norm if norm > 0 else 0
    return 1 - similarity


def get_embeddings(client, texts, model="text-embedding-3-large"):
    response = client.embeddings.create(input=texts, model=model)
    return [item.embedding for item in response.data]


def calculate_sem_div(client, text):
    sentences = sent_tokenize(text)
    if len(sentences) < 2:
        return 0.0, sentences
    embeddings = get_embeddings(client, sentences)
    distances = []
    for i in range(len(sentences)):
        for j in range(i):
            dist = cosine_distance(embeddings[i], embeddings[j])
            distances.append(dist)
    return np.mean(distances), sentences


def calculate_lex_div(text):
    tokens = word_tokenize(text.lower())
    tokens = [t for t in tokens if t.isalpha()]
    if len(tokens) == 0:
        return 0.0, 0, 0
    unique_tokens = set(tokens)
    return len(unique_tokens) / len(tokens), len(unique_tokens), len(tokens)


def analyze_originality(api_key, passage_a, passage_b):
    if not api_key.strip():
        return "Error: OpenAI API 키를 입력하세요."
    if not passage_a.strip() or not passage_b.strip():
        return "Error: 두 단락 모두 입력하세요."

    try:
        client = OpenAI(api_key=api_key.strip())

        # Passage A 분석
        sem_div_a, sentences_a = calculate_sem_div(client, passage_a)
        lex_div_a, unique_a, total_a = calculate_lex_div(passage_a)
        score_a = 0.50 * sem_div_a + 0.50 * lex_div_a

        # Passage B 분석
        sem_div_b, sentences_b = calculate_sem_div(client, passage_b)
        lex_div_b, unique_b, total_b = calculate_lex_div(passage_b)
        score_b = 0.50 * sem_div_b + 0.50 * lex_div_b

        # 차이 계산
        diff = score_a - score_b
        lower_score = min(score_a, score_b)
        diff_percent = (abs(diff) / lower_score) * 100 if lower_score > 0 else 0

        # 판정
        if diff_percent < 5:
            judgment = "비슷함"
        elif diff_percent < 10:
            judgment = "차이 있음"
        elif diff_percent < 15:
            judgment = "유의미한 차이"
        else:
            judgment = "확실한 차이"

        # 결과 텍스트
        result = f"""
{'='*50}
                   분석 결과
{'='*50}

{'항목':<15} {'Passage A':>15} {'Passage B':>15}
{'-'*50}
{'문장 수':<15} {len(sentences_a):>15} {len(sentences_b):>15}
{'고유 단어':<15} {unique_a:>15} {unique_b:>15}
{'전체 단어':<15} {total_a:>15} {total_b:>15}
{'-'*50}
{'sem_div':<15} {sem_div_a:>15.4f} {sem_div_b:>15.4f}
{'lex_div':<15} {lex_div_a:>15.4f} {lex_div_b:>15.4f}
{'독창성 점수':<15} {score_a:>15.4f} {score_b:>15.4f}

{'='*50}
                   차이 비율
{'='*50}
점수 차이: {abs(diff):.4f}
차이 비율: {diff_percent:.1f}%
판정: {judgment}

{'='*50}
                   최종 판정
{'='*50}
"""
        if diff_percent < 5:
            result += f"두 텍스트의 독창성은 비슷함 (차이 {diff_percent:.1f}%)"
        elif diff > 0:
            result += f"Passage A가 더 독창적 (차이 {diff_percent:.1f}%, {judgment})"
        else:
            result += f"Passage B가 더 독창적 (차이 {diff_percent:.1f}%, {judgment})"

        return result

    except Exception as e:
        return f"Error: {str(e)}"


# Gradio 인터페이스
demo = gr.Interface(
    fn=analyze_originality,
    inputs=[
        gr.Textbox(label="OpenAI API Key", type="password", placeholder="sk-..."),
        gr.Textbox(label="Passage A", lines=8, placeholder="첫 번째 단락 입력..."),
        gr.Textbox(label="Passage B", lines=8, placeholder="두 번째 단락 입력...")
    ],
    outputs=gr.Textbox(label="분석 결과", lines=25),
    title="OpenAI Embedding 독창성 분석",
    description="두 단락의 독창성을 비교합니다. (sem_div 50% + lex_div 50%)",
    flagging_mode="never"
)

if __name__ == "__main__":
    demo.launch()