def translate_first_prompting(text, source_lang, target_lang, task):
    # 第一步：翻譯到英語
    english_text = translate_to_english(text, source_lang)

    # 第二步：執行任務
    prompt = f"""
    Perform the following task on the given text:
    Task: {task}
    Text: "{english_text}"
    """
    result = openai.Completion.create(
        engine="text-davinci-002",
        prompt=prompt,
        max_tokens=100,
        temperature=0.7
    ).choices[0].text.strip()

    # 第三步：翻譯回原語言（如果需要）
    if target_lang != "english":
        result = translate_from_english(result, target_lang)

    return result

# 使用示例
text = "這是一個需要分類的中文句子。"
task = "Classify the sentiment of this sentence as positive, negative, or neutral."
result = translate_first_prompting(text, "chinese", "chinese", task)
print(result)

def multilingual_few_shot(text, lang, task):
    prompt = f"""
    Perform the given task on texts in different languages.

    Task: {task}

    Examples:
    Text (English): "This movie was fantastic! I loved every minute of it."
    Result: Positive

    Text (English): "The service at this restaurant was terrible. I'll never come back."
    Result: Negative

    Text (English): "The weather today is cloudy with a chance of rain."
    Result: Neutral

    Now perform the task on the following text:
    Text ({lang}): "{text}"
    Result:
    """

    response = openai.Completion.create(
        engine="text-davinci-002",
        prompt=prompt,
        max_tokens=50,
        temperature=0.7
    )

    return response.choices[0].text.strip()

# 使用示例
text = "Ce film était incroyable ! Je le recommande vivement."
task = "Classify the sentiment as Positive, Negative, or Neutral"
result = multilingual_few_shot(text, "French", task)
print(result)

def multilingual_cot(text, lang, task):
    prompt = f"""
    Solve the given task step by step in the specified language.

    Task: {task}

    Example (English):
    Question: If a shirt costs $15 and is on sale for 20% off, what is the final price?
    Step 1: Understand the given information
    - Original price: $15
    - Discount: 20%
    Step 2: Calculate the discount amount
    - Discount amount = $15 × 20% = $15 × 0.20 = $3
    Step 3: Subtract the discount from the original price
    - Final price = $15 - $3 = $12
    Therefore, the final price of the shirt is $12.

    Now solve this problem:
    Question ({lang}): {text}
    Step 1:
    """

    response = openai.Completion.create(
        engine="text-davinci-002",
        prompt=prompt,
        max_tokens=200,
        temperature=0.7
    )

    return response.choices[0].text.strip()

# 使用示例
text = "Si une chemise co?te 50 euros et est en solde avec une réduction de 30%, quel est le prix final ?"
task = "Solve this math problem"
result = multilingual_cot(text, "French", task)
print(result)

def cross_lingual_prompting(text, source_lang, target_lang, task):
    prompt = f"""
    Perform the following task:
    Task (English): {task}

    Here are some examples in different languages:

    Input (English): "The company's profits increased by 15% last quarter."
    Output (French): "Les bénéfices de l'entreprise ont augmenté de 15% le trimestre dernier."

    Input (Spanish): "La nueva política ambiental ha generado mucho debate."
    Output (German): "Die neue Umweltpolitik hat viele Diskussionen ausgel?st."

    Now, perform the task on this input:
    Input ({source_lang}): {text}
    Output ({target_lang}):
    """

    response = openai.Completion.create(
        engine="text-davinci-002",
        prompt=prompt,
        max_tokens=100,
        temperature=0.7
    )

    return response.choices[0].text.strip()

# 使用示例
text = "人工智能正在改變我們的生活方式。"
task = "Translate the input text and then summarize its main idea."
result = cross_lingual_prompting(text, "Chinese", "English", task)
print(result)

def language_identified_prompt(text, source_lang, target_lang, task):
    prompt = f"""
    Source language: {source_lang}
    Target language: {target_lang}
    Task: {task}

    Input: {text}

    Output:
    """
    # ... 使用這個提示調用模型 ...

multilingual_examples = """
English: The weather is nice today.
French: Il fait beau aujourd'hui.
Spanish: El tiempo está agradable hoy.
German: Das Wetter ist heute sch?n.

English: I love reading books.
French: J'aime lire des livres.
Spanish: Me encanta leer libros.
German: Ich liebe es, Bücher zu lesen.
"""

def multilingual_prompt(text, lang, task):
    prompt = f"""
    {multilingual_examples}

    Task: {task}

    {lang}: {text}
    """
    # ... 使用這個提示調用模型 ...

language_context = {
    "french": "Consider French cultural norms and expressions.",
    "japanese": "Be mindful of Japanese honorifics and levels of politeness.",
    "arabic": "Remember that Arabic is written from right to left."
}

def contextualized_prompt(text, lang, task):
    context = language_context.get(lang.lower(), "")
    prompt = f"""
    Language: {lang}
    Context: {context}
    Task: {task}

    Input: {text}

    Output:
    """
    # ... 使用這個提示調用模型 ...

def back_translation_evaluation(original_text, translated_text, source_lang, target_lang):
    # 將翻譯后的文本再次翻譯回原語言
    back_translated = translate(translated_text, target_lang, source_lang)

    # 計算原文和回譯文本的相似度
    similarity = calculate_similarity(original_text, back_translated)

    return similarity

def calculate_similarity(text1, text2):
    # 這里可以使用各種文本相似度算法，如余弦相似度、BLEU分數等
    # 這里我們使用一個簡化的實現
    return len(set(text1.split()) & set(text2.split())) / len(set(text1.split() + text2.split()))

# 使用示例
original = "人工智能正在改變我們的生活方式。"
translated = "Artificial intelligence is changing our way of life."
similarity = back_translation_evaluation(original, translated, "chinese", "english")
print(f"Back-translation similarity: {similarity}")

import openai

def multilingual_customer_service_bot(query, lang):
    # 定義常見問題及其回答
    faq = {
        "return_policy": {
            "english": "Our return policy allows returns within 30 days of purchase.",
            "french": "Notre politique de retour permet les retours dans les 30 jours suivant l'achat.",
            "spanish": "Nuestra política de devolución permite devoluciones dentro de los 30 días posteriores a la compra."
        },
        "shipping_time": {
            "english": "Shipping usually takes 3-5 business days.",
            "french": "La livraison prend généralement 3 à 5 jours ouvrables.",
            "spanish": "El envío generalmente toma de 3 a 5 días hábiles."
        }
    }

    prompt = f"""
    You are a multilingual customer service AI for an international e-commerce platform.
    Respond to the customer's query in their language. If the query matches a common question, use the provided answer.
    If not, generate an appropriate response.

    Common questions and answers:
    1. Return Policy:
       EN: {faq['return_policy']['english']}
       FR: {faq['return_policy']['french']}
       ES: {faq['return_policy']['spanish']}

    2. Shipping Time:
       EN: {faq['shipping_time']['english']}
       FR: {faq['shipping_time']['french']}
       ES: {faq['shipping_time']['spanish']}

    Customer's language: {lang}
    Customer's query: {query}

    Your response in {lang}:
    """

    response = openai.Completion.create(
        engine="text-davinci-002",
        prompt=prompt,
        max_tokens=150,
        temperature=0.7
    )

    return response.choices[0].text.strip()

# 使用示例
queries = [
    ("What's your return policy?", "english"),
    ("Combien de temps prend la livraison ?", "french"),
    ("?Tienen una tienda física en Madrid?", "spanish")
]

for query, lang in queries:
    response = multilingual_customer_service_bot(query, lang)
    print(f"Query ({lang}): {query}")
    print(f"Response: {response}\n")

def culturally_aware_prompt(text, source_lang, target_lang, task):
    cultural_context = {
        "japanese": "In Japanese culture, indirect communication and politeness are highly valued.",
        "german": "German communication style tends to be more direct and precise.",
        # 添加更多語言的文化上下文
    }

    prompt = f"""
    Source language: {source_lang}
    Target language: {target_lang}
    Cultural context: {cultural_context.get(target_lang.lower(), "")}
    Task: {task}

    Considering the cultural context, {task} for the following text:
    {text}

    Output:
    """
    # 使用這個提示調用模型