app.py

import gradio as gr
import pandas as pd
import os
import random
import re
import pymorphy3
import requests
import json
import base64
import time
from openai import OpenAI
import string

XAI_API_KEY = os.getenv("XAI_API_KEY")
client = OpenAI(
    api_key=XAI_API_KEY,
    base_url="https://api.x.ai/v1",
)
token = os.getenv('GITHUB_TOKEN')
repo = "fruitpicker01/Storage_Anastasia"
current_request_index = -1

def load_dropdown_data(file_path, sheet_name, column_name):
    data = pd.read_excel(file_path, sheet_name=sheet_name)
    return data[column_name].dropna().unique().tolist()

file_path = "Исходные данные.xlsx"
products_list, data_products = load_dropdown_data(file_path, "Продукты", "Наименование продукта"), pd.read_excel(file_path, sheet_name="Продукты")
products = ["Свой продукт"] + list(products_list)

genders_data = pd.read_excel(file_path, sheet_name="Пол")
generations_data = pd.read_excel(file_path, sheet_name="Поколение")
psychotypes_data = pd.read_excel(file_path, sheet_name="Психотип")
business_stages_data = pd.read_excel(file_path, sheet_name="Стадия бизнеса")
industries_data = pd.read_excel(file_path, sheet_name="Отрасль")
opfs_data = pd.read_excel(file_path, sheet_name="ОПФ")

genders = genders_data["Пол"].dropna().unique().tolist()
generations = generations_data["Поколение"].dropna().unique().tolist()
psychotypes = psychotypes_data["Психотип"].dropna().unique().tolist()
business_stages = business_stages_data["Стадия бизнеса"].dropna().unique().tolist()
industries = industries_data["Отрасль"].dropna().unique().tolist()
opfs = opfs_data["ОПФ"].dropna().unique().tolist()

approaches_data = pd.read_excel(file_path, sheet_name="Подход")

approach_dict = {
    "Указание на пользу": {
        "prefix": "Начни SMS с указания на пользу продукта. Используй глагол в побудительном наклонении. Не начинай с вопроса",
        "suffix": "Убедись, что SMS начинается с указания на пользу продукта и использования глагола в побудительном наклонении и не начинается с вопроса"
    },
    "Вопрос": {
        "prefix": "Начни сообщение с вопроса, который указывает на пользу продукта для клиента",
        "suffix": "Убедись, что готовый текст начинается с вопроса, который указывает на пользу продукта для клиента"
    },
    "Призыв к действию": {
        "prefix": "Начни SMS с призыва к действию с продуктом. Не начинай с вопроса",
        "suffix": "Убедись, что готовый текст начинается с призыва к действию с продуктом и не начинается с вопроса"
    }
}

def fill_product_details(selected_product, data):
    if selected_product == "Свой продукт":
        return (gr.update(value="", interactive=True),
                gr.update(value="", interactive=True),
                gr.update(value="", interactive=True),
                gr.update(value="", interactive=True))
    else:
        if selected_product and selected_product in data["Наименование продукта"].values:
            product_row = data[data["Наименование продукта"] == selected_product].iloc[0]
            return (gr.update(value=product_row.get("Описание предложения", ""), interactive=False),
                    gr.update(value=product_row.get("Наименование продукта", ""), interactive=False),
                    gr.update(value=product_row.get("Преимущества", ""), interactive=False),
                    gr.update(value=product_row.get("Ключевое сообщение", ""), interactive=False))
        else:
            return (gr.update(value="", interactive=False),
                    gr.update(value="", interactive=False),
                    gr.update(value="", interactive=False),
                    gr.update(value="", interactive=False))

def get_approaches(gender, generation, psychotype, approaches_df):
    if approaches_df is None or approaches_df.empty:
        return "Подход не найден для выбранных параметров."
    filters = []
    for param_name, param_value in [('Пол', gender), ('Поколение', generation), ('Психотип', psychotype)]:
        if not param_value or param_value == "Не выбрано":
            filters.append(approaches_df[param_name].isnull() | (approaches_df[param_name].fillna('') == ''))
        else:
            filters.append(approaches_df[param_name].fillna('') == param_value)
    combined_filter = filters[0]
    for f in filters[1:]:
        combined_filter &= f
    matching_rows = approaches_df[combined_filter]
    if matching_rows.empty:
        return "Подход не найден для выбранных параметров."
    approach_list = []
    for approaches in matching_rows['Подход']:
        approach_names = [a.strip() for a in str(approaches).split(',')]
        approach_list.extend(approach_names)
    approach_list = list(set(approach_list))
    return ', '.join(approach_list)

def get_instructions_for_param(param_value, df, col):
    if not param_value or param_value == "Не выбрано":
        return None
    row = df[df[col] == param_value]
    if row.empty:
        return None
    instr1 = row.iloc[0].get("Инструкция 1", "")
    if not instr1.strip():
        return None
    return instr1

def format_instruction_string(instr):
    terms = [t.strip() for t in instr.split(',') if t.strip()]
    return ", ".join(terms) if terms else ""

def generate_display_prompts(description, product_name, benefits, key_message, chosen_approach,
                             gender, generation, psychotype, business_stage, industry, opf):
    if chosen_approach == "Подход не найден для выбранных параметров.":
        return ("Для формирования промпта выберите хотя бы один личный персональный параметр для определения подхода",
                "Для формирования промпта выберите хотя бы один личный персональный параметр для определения подхода")
    approach_list = [a.strip() for a in chosen_approach.split(',') if a.strip()]
    prefix_parts = []
    suffix_parts = []
    for a in approach_list:
        if a in approach_dict:
            prefix_parts.append(approach_dict[a]["prefix"])
            suffix_parts.append(approach_dict[a]["suffix"])
    if len(prefix_parts) > 1:
        approach_prefix = " / ".join(prefix_parts)
        approach_suffix = " / ".join(suffix_parts)
    else:
        approach_prefix = prefix_parts[0] if prefix_parts else ""
        approach_suffix = suffix_parts[0] if suffix_parts else ""
    instructions_data = [
        (gender, genders_data, "Пол"),
        (generation, generations_data, "Поколение"),
        (psychotype, psychotypes_data, "Психотип"),
        (business_stage, business_stages_data, "Стадия бизнеса"),
        (industry, industries_data, "Отрасль"),
        (opf, opfs_data, "ОПФ")
    ]
    chosen_params_instructions = []
    for (param_value, df, col) in instructions_data:
        instr1 = get_instructions_for_param(param_value, df, col)
        if instr1:
            chosen_params_instructions.append(instr1)
    if not chosen_params_instructions:
        return ("Для формирования промпта выберите хотя бы один личный персональный параметр для определения подхода",
                "Для формирования промпта выберите хотя бы один личный персональный параметр для определения подхода")
    lines = []
    for i, instr_line in enumerate(chosen_params_instructions, start=1):
        formatted_line = format_instruction_string(instr_line)
        lines.append(f"{i}. {formatted_line}.")
    mandatory_terms = "\n".join(lines)
    
    extra_line = ""
    if generation == "Z":
        extra_line = "Обратись в SMS на ты. "

    prompt_1 = f"""Напиши три или четыре предложения суммарной длиной от 160 до 250 знаков с учетом пробелов. {approach_prefix}. 
{extra_line}Напиши рекламное SMS для следующего продукта:
«{description}».
Не изменяй название продукта: «{product_name}».
Преимущества:
«{benefits}».
ОБЯЗАТЕЛЬНО используй в SMS один или несколько терминов, касающиеся клиента, которому направляется SMS, из КАЖДОЙ группы:
{mandatory_terms}
Убедись, что написал не меньше трех и не больше четырех предложений суммарной длиной от 160 до 250 знаков с учетом пробелов.
{approach_suffix}.
Убедись, что УМЕСТНО использовал КАЖДЫЙ необходимый термин.
Убедись, что в SMS без изменений, синонимов и перестановок слов используется наименование продукта: «{product_name}».
Убедись, что в SMS есть следующая ключевая информация: «{key_message}»."""

    prompt_2 = f"""Напиши три или четыре предложения суммарной длиной от 160 до 250 знаков с учетом пробелов. {approach_prefix}. 
{extra_line}Напиши рекламное SMS для следующего продукта:
«{description}».
Не изменяй название продукта: «{product_name}».
Преимущества:
«{benefits}».
Используй в SMS РОВНО один или несколько терминов, касающиеся клиента, которому направляется SMS, из КАЖДОЙ группы:
{mandatory_terms}
Убедись, что написал не меньше трех и не больше четырех предложений суммарной длиной от 160 до 250 знаков с учетом пробелов.
{approach_suffix}.
Убедись, что УМЕСТНО использовал КАЖДЫЙ необходимый термин.
Убедись, что в SMS без изменений, синонимов и перестановок слов используется наименование продукта: «{product_name}».
Убедись, что в SMS есть следующая ключевая информация: «{key_message}»."""

    return prompt_1, prompt_2

def call_model(model_prompt):
    completion = client.chat.completions.create(
        model="grok-2-1212",
        messages=[
            {"role": "system", "content": "You are a world-class expert in creating personalized SMS who returns only the SMS and nothing else."},
            {"role": "user", "content": model_prompt},
        ],
    )
    return completion.choices[0].message.content.strip()

def correct_dash_usage(text):
    return text

def clean_message(message):
    if not message.endswith(('.', '!', '?')):
        last_period = max(message.rfind('.'), message.rfind('!'), message.rfind('?'))
        if last_period != -1:
            message = message[:last_period + 1]
    return message

def tokenize_words(text):
    """
    Разбивает текст на слова, игнорируя знаки препинания.
    """
    return re.findall(r'\w+', text, re.UNICODE)

def normalize(word):
    """
    Возвращает начальную форму слова с помощью pymorphy3.
    Приводит к нижнему регистру для унификации.
    """
    morph = pymorphy3.MorphAnalyzer()
    parsed = morph.parse(word)
    if parsed:
        return parsed[0].normal_form.lower()
    return word.lower()

def find_word_matches(normalized_msg, normalized_prod):
    """
    Находит индексы начала совпадений названия продукта в нормализованных словах.
    """
    matches = []
    prod_len = len(normalized_prod)
    for i in range(len(normalized_msg) - prod_len + 1):
        window = normalized_msg[i:i+prod_len]
        if window == normalized_prod:
            matches.append(i)
    return matches

def get_word_positions(message):
    """
    Возвращает список кортежей (слово, start_index, end_index) для каждого слова в сообщении.
    """
    word_positions = []
    for match in re.finditer(r'\w+', message):
        word = match.group(0)
        start = match.start()
        end = match.end()
        word_positions.append((word, start, end))
    return word_positions

def capitalize_sentences(text):
    """
    Капитализирует первую букву каждого предложения в тексте.
    Предложения считаются разделенными точками, восклицательными или вопросительными знаками.
    """
    # Разделяем текст на предложения
    sentence_endings = re.compile(r'([.!?])')
    parts = sentence_endings.split(text)

    # Объединяем разделенные части и капитализируем первые буквы
    sentences = []
    for i in range(0, len(parts)-1, 2):
        sentence = parts[i].strip()
        punctuation = parts[i+1]
        if sentence:
            sentence = sentence[0].upper() + sentence[1:]
            sentences.append(sentence + punctuation)

    # Обработка возможного остатка текста без завершающего знака
    if len(parts) % 2 != 0 and parts[-1].strip():
        last_sentence = parts[-1].strip()
        last_sentence = last_sentence[0].upper() + last_sentence[1:]
        sentences.append(last_sentence)

    # Объединяем обратно в текст
    return ' '.join(sentences)

def process_message(message, product_name):
    """
    Обрабатывает сообщение, заменяя название продукта.
    - Первое слово сохраняется в инфлектированной форме, как в сообщении.
    - Остальные слова заменяются на оригинальные слова из названия продукта, сохраняя их капитализацию.
    Возвращает обработанное сообщение.
    """
    # Токенизация сообщения (без пунктуации)
    message_words = tokenize_words(message)
    normalized_message = [normalize(word) for word in message_words]

    # Токенизация названия продукта
    product_words_original = tokenize_words(product_name)  # Оригинальные слова с капитализацией
    normalized_product = [normalize(word) for word in product_words_original]

    # Поиск совпадений
    matches = find_word_matches(normalized_message, normalized_product)

    if not matches:
        # Если совпадений нет, вернуть исходное сообщение с капитализацией предложений
        return message

    # Получаем позиции всех слов в сообщении
    word_positions = get_word_positions(message)

    # Обработка каждого совпадения
    # Для избежания смещения индексов при множественных заменах, обрабатываем с конца
    matches_sorted = sorted(matches, reverse=True)

    final_message = message

    for match in matches_sorted:
        # Индексы слов
        start_word_idx = match
        end_word_idx = match + len(product_words_original) - 1

        # Проверка, чтобы индексы не выходили за пределы списка
        if end_word_idx >= len(word_positions):
            continue  # Пропускаем некорректные совпадения

        # Получаем позиции слов
        start_char = word_positions[start_word_idx][1]
        end_char = word_positions[end_word_idx][2]


        # Извлечение изменяемой части
        matched_substring = final_message[start_char:end_char]

        # Извлечение неизменяемой части
        before = final_message[:start_char]
        after = final_message[end_char:]

        # Разделяем изменяемую часть на слова
        words = matched_substring.replace('«', '').replace('»', '').strip().split()

        if len(words) < len(product_words_original):
            # Несоответствие количества слов, пропускаем замену
            continue

        # Сохраняем первое слово как есть (инфлектированное)
        first_word = words[0]
        clean_words = []
        for i in range(len(product_words_original[1:])):
            if product_words_original[1:][i] == "Карта":
                clean_words.append(words[i+1])
            else:
                clean_words.append(product_words_original[1:][i])

        # Остальные слова берем из оригинального названия продукта
        replaced_words = [first_word] + clean_words

        # Собираем обратно измененную часть
        processed = ' '.join(replaced_words)

        # Воссоединяем части сообщения
        final_message = before + processed + after

    # Удаляем лишние пробелы
    final_message = re.sub(r'\s+', ' ', final_message).strip()

    # Капитализируем предложения
    final_message = capitalize_sentences(final_message)

    return final_message

def generate_message_with_retry(model_prompt, product_name):
    last_message = ""
    for _ in range(10):
        msg = call_model(model_prompt)
        msg = correct_dash_usage(msg)
        msg = clean_message(msg)
        msg = process_message(msg, product_name)
        length = len(msg)
        if 160 <= length <= 250:
            msg += f"\n\n------\nКоличество знаков: {length}"
            return msg
        last_message = msg
    length = len(last_message)
    last_message += f"\n\n------\nКоличество знаков: {length}"
    return last_message

def update_prompts_on_params_change(description, product_name, benefits, key_message, 
                                    gender, generation, psychotype, business_stage, industry, opf):
    chosen_approach = get_approaches(gender, generation, psychotype, approaches_data)
    prompt_1, prompt_2 = generate_display_prompts(description, product_name, benefits, key_message,
                                                  chosen_approach, gender, generation, psychotype,
                                                  business_stage, industry, opf)
    return chosen_approach, prompt_1, prompt_2

def save_user_request_to_github(selected_product, description, product_name, benefits, key_message, approach, personalization_params):
    global current_request_index
    current_request_index = -1
    data_to_save = {
        "selected_product": selected_product,
        "description": description,
        "product_name": product_name,
        "benefits": benefits,
        "key_message": key_message,
        "approach": approach,
        "personalization_params": personalization_params,
        "timestamp": time.time()
    }
    file_content_encoded = base64.b64encode(json.dumps(data_to_save).encode()).decode()
    path = f"user_request_{int(time.time())}.json"
    url = f"https://api.github.com/repos/{repo}/contents/{path}"
    headers = {
        "Authorization": f"token {token}",
        "Content-Type": "application/json"
    }
    data = {
        "message": f"Добавлен новый файл {path}",
        "content": file_content_encoded
    }
    requests.put(url, headers=headers, data=json.dumps(data))

def load_previous_user_request_from_github():
    global current_request_index
    url = f"https://api.github.com/repos/{repo}/contents"
    headers = {
        "Authorization": f"token {token}",
        "Content-Type": "application/json"
    }
    response = requests.get(url, headers=headers)
    if response.status_code == 200:
        files = response.json()
        json_files = [file for file in files if file['name'].startswith("user_request_")]
        if not json_files:
            return products[0], "", "", "", "", "", None, None, None, None, None, "", "", "", "", "", ""
        current_request_index -= 1
        if abs(current_request_index) > len(json_files):
            current_request_index = -len(json_files)
        target_file = json_files[current_request_index]
        file_url = target_file['download_url']
        file_response = requests.get(file_url)
        if file_response.status_code == 200:
            data = json.loads(file_response.text)
            selected_product = data.get('selected_product', products[0])
            description = data.get('description', "")
            product_name = data.get('product_name', "")
            benefits = data.get('benefits', "")
            key_message = data.get('key_message', "")
            approach = data.get('approach', "")
            personalization_params = data.get('personalization_params', [None]*6)
            if len(personalization_params) < 6:
                personalization_params += [None]*(6-len(personalization_params))
            return (selected_product, description, product_name, benefits, key_message, approach, *personalization_params)
        else:
            return products[0], "", "", "", "", "", None, None, None, None, None, "", "", "", "", "", ""
    else:
        return products[0], "", "", "", "", "", None, None, None, None, None, "", "", "", "", "", ""

def generate_final_prompt_from_display(prompt_text, single_approach, is_prompt_1=True):
    chosen_prefix = approach_dict[single_approach]["prefix"]
    chosen_suffix = approach_dict[single_approach]["suffix"]
    for approach in approach_dict:
        if approach != single_approach:
            other_prefix = approach_dict[approach]["prefix"]
            other_suffix = approach_dict[approach]["suffix"]
            prompt_text = prompt_text.replace(other_prefix, "")
            prompt_text = prompt_text.replace(other_suffix, "")
    prompt_text = prompt_text.replace(" / ", " ")
    prompt_text = re.sub(r"\s{2,}", " ", prompt_text).strip()
    if chosen_prefix not in prompt_text:
        prompt_text = re.sub(r"с учетом пробелов\. [^.\n]*\.", f"с учетом пробелов. {chosen_prefix}.", prompt_text)
    if chosen_suffix not in prompt_text:
        prompt_text = re.sub(r"\n[^\n]*Убедись, что УМЕСТНО использовал КАЖДЫЙ необходимый термин.\n[^\n]*Убедись, что в SMS без.*\n[^\n]*Убедись, что в SMS есть следующая ключевая информация:",
                             f"\n{chosen_suffix}.\nУбедись, что УМЕСТНО использовал КАЖДЫЙ необходимый термин.\nУбедись, что в SMS без изменений, синонимов и перестановок слов используется наименование продукта:\nУбедись, что в SMS есть следующая ключевая информация:", prompt_text, flags=re.DOTALL)
    prompt_text = re.sub(r"\s+([.,!?])", r"\1", prompt_text)
    return prompt_text

final_prompt_1_state = gr.State("")
final_prompt_2_state = gr.State("")

def generate_personalized_sms_wrapper(selected_product, description, product_name, benefits, key_message,
                                      gender, generation, psychotype, business_stage, industry, opf,
                                      chosen_approach, prompt_1, prompt_2):
    if "Для формирования промпта выберите хотя бы один личный персональный параметр" in prompt_1 or chosen_approach == "Подход не найден для выбранных параметров.":
        gr.Warning("Задайте хотя бы один личный персональный параметр для определения подхода")
        return "", "", "", ""
    approach_list = [a.strip() for a in chosen_approach.split(',') if a.strip()]
    if not approach_list:
        gr.Warning("Задайте хотя бы один личный персональный параметр для определения подхода")
        return "", "", "", ""
    chosen_single_approach_1 = random.choice(approach_list) if len(approach_list) > 1 else approach_list[0]
    chosen_single_approach_2 = random.choice(approach_list) if len(approach_list) > 1 else approach_list[0]
    final_prompt_1 = generate_final_prompt_from_display(prompt_1, chosen_single_approach_1, is_prompt_1=True)
    final_prompt_2 = generate_final_prompt_from_display(prompt_2, chosen_single_approach_2, is_prompt_1=False)
    print("Final Prompt 1:", final_prompt_1)
    print("Final Prompt 2:", final_prompt_2)
    sms_1 = generate_message_with_retry(final_prompt_1, product_name)
    sms_2 = generate_message_with_retry(final_prompt_2, product_name)

    # Выполняем проверки sms_1
    cut_sms_1 = cut_message(sms_1)
    checks_1 = perform_checks(cut_sms_1, key_message)
    checks_formatted_1 = format_checks(checks_1)

    # Выполняем проверки sms_2
    cut_sms_2 = cut_message(sms_2)
    checks_2 = perform_checks(cut_sms_2, key_message)
    checks_formatted_2 = format_checks(checks_2)
    
    personalization_params = [gender, generation, psychotype, business_stage, industry, opf]
    save_user_request_to_github(selected_product, description, product_name, benefits, key_message, chosen_approach, personalization_params)
    return sms_1, sms_2, final_prompt_1, final_prompt_2, checks_formatted_1, checks_formatted_2

def on_regenerate(
    selected_product, description, product_name, benefits, key_message,
    gender, generation, psychotype, business_stage, industry, opf,
    chosen_approach, presence_in_db,
    model_1_name, prompt_1, final_prompt_1, sms_1,
    model_2_name, prompt_2, final_prompt_2, sms_2
):
    """
    Функция для кнопки «Перегенерировать SMS (не нравится ни одно из SMS)».
    1) Перегенерирует sms_1, sms_2 с помощью final_prompt_1, final_prompt_2 и product_name.
    2) Сохраняет все те же данные, что и on_prefer_sms_1/2, но с chosen_sms="none".
    3) Возвращает новые sms_1, sms_2 для обновления интерфейса.
    """

    # Перегенерируем SMS (аналогично regen_sms)
    if not final_prompt_1.strip() or not final_prompt_2.strip():
        gr.Warning("Нечего перегенерировать, сначала создайте SMS.")
        return "", ""

    print("Regen Final Prompt 1:", final_prompt_1)
    print("Regen Final Prompt 2:", final_prompt_2)

    sms_1 = generate_message_with_retry(final_prompt_1, product_name)
    sms_2 = generate_message_with_retry(final_prompt_2, product_name)

    # Проверяем заново:
    cut_sms_1 = cut_message(sms_1)
    checks_1 = perform_checks(cut_sms_1, key_message)
    checks_formatted_1 = format_checks(checks_1)

    cut_sms_2 = cut_message(sms_2)
    checks_2 = perform_checks(cut_sms_2, key_message)
    checks_formatted_2 = format_checks(checks_2)

    # Теперь сохраняем всё, как при «Я предпочитаю это SMS»,
    # только chosen_sms="none"
    save_preferred_sms_to_github(
        selected_product, description, product_name, benefits, key_message,
        gender, generation, psychotype, business_stage, industry, opf,
        chosen_approach, presence_in_db,
        model_1_name, prompt_1, final_prompt_1, sms_1,
        model_2_name, prompt_2, final_prompt_2, sms_2,
        chosen_sms="none"  # <-- признак, что ни одно SMS не выбрано
    )

    return sms_1, sms_2, checks_formatted_1, checks_formatted_2

def on_load_previous():
    loaded_data = load_previous_user_request_from_github()
    if not loaded_data or len(loaded_data) < 11:
        return (products[0], "", "", "", "", None, None, None, None, None, None, "", "", "", "", "", "")
    selected_product_val, description_val, product_name_val, benefits_val, key_message_val, approach_val = loaded_data[0], loaded_data[1], loaded_data[2], loaded_data[3], loaded_data[4], loaded_data[5]
    gender_val, generation_val, psychotype_val, business_stage_val, industry_val, opf_val = loaded_data[6:12]
    chosen_approach_val, p1, p2 = update_prompts_on_params_change(description_val, product_name_val, benefits_val, key_message_val,
                                                                  gender_val, generation_val, psychotype_val,
                                                                  business_stage_val, industry_val, opf_val)
    return (selected_product_val, description_val, product_name_val, benefits_val, key_message_val,
            gender_val, generation_val, psychotype_val, business_stage_val, industry_val, opf_val,
            chosen_approach_val, p1, p2, "", "", "")

def save_preferred_sms_to_github(
    selected_product, description, product_name, benefits, key_message,
    gender, generation, psychotype, business_stage, industry, opf,
    chosen_approach, presence_in_db,
    model_1_name, prompt_1, final_prompt_1, sms_1,
    model_2_name, prompt_2, final_prompt_2, sms_2,
    chosen_sms
):
    """
    Сохраняет выбранные поля в отдельный JSON-файл на GitHub,
    чтобы не смешивать с предыдущими действиями, сохраняем под другим названием.
    """
    # Собираем все данные
    data_to_save = {
        "timestamp": time.time(),
        "product_dropdown": selected_product,
        "description": description,
        "product_name": product_name,
        "benefits": benefits,
        "key_message": key_message,
        "gender": gender,
        "generation": generation,
        "psychotype": psychotype,
        "business_stage": business_stage,
        "industry": industry,
        "opf": opf,
        "chosen_approach": chosen_approach,
        "comment": presence_in_db,
        "model_1_name": model_1_name,
        "prompt_1": prompt_1,
        "final_prompt_1": final_prompt_1,
        "sms_1": sms_1,
        "model_2_name": model_2_name,
        "prompt_2": prompt_2,
        "final_prompt_2": final_prompt_2,
        "sms_2": sms_2,
        "preferred_sms": chosen_sms  # "sms_1" или "sms_2"
    }

    file_content_encoded = base64.b64encode(json.dumps(data_to_save).encode()).decode()
    filename = f"preferred_sms_{int(time.time())}.json"
    url = f"https://api.github.com/repos/{repo}/contents/{filename}"
    headers = {
        "Authorization": f"token {token}",
        "Content-Type": "application/json"
    }
    data = {
        "message": f"Добавлен файл {filename} со сведениями о предпочтённом SMS",
        "content": file_content_encoded
    }
    response = requests.put(url, headers=headers, data=json.dumps(data))
    if response.status_code == 201:
        print(f"Файл {filename} успешно сохранен.")
    else:
        print(f"Ошибка при сохранении данных: {response.status_code}, {response.text}")

def on_prefer_sms_1(
    selected_product, description, product_name, benefits, key_message,
    gender, generation, psychotype, business_stage, industry, opf,
    chosen_approach, presence_in_db,
    model_1_name, prompt_1, final_prompt_1, sms_1,
    model_2_name, prompt_2, final_prompt_2, sms_2
):
    """
    Вызывается при нажатии кнопки «Я предпочитаю это SMS» (для SMS 1).
    """
    save_preferred_sms_to_github(
        selected_product, description, product_name, benefits, key_message,
        gender, generation, psychotype, business_stage, industry, opf,
        chosen_approach, presence_in_db,
        model_1_name, prompt_1, final_prompt_1, sms_1,
        model_2_name, prompt_2, final_prompt_2, sms_2,
        chosen_sms="sms_1"
    )
    return "Предпочтение SMS 1 сохранено в GitHub"

def on_prefer_sms_2(
    selected_product, description, product_name, benefits, key_message,
    gender, generation, psychotype, business_stage, industry, opf,
    chosen_approach, presence_in_db,
    model_1_name, prompt_1, final_prompt_1, sms_1,
    model_2_name, prompt_2, final_prompt_2, sms_2
):
    """
    Вызывается при нажатии кнопки «Я предпочитаю это SMS» (для SMS 2).
    """
    save_preferred_sms_to_github(
        selected_product, description, product_name, benefits, key_message,
        gender, generation, psychotype, business_stage, industry, opf,
        chosen_approach, presence_in_db,
        model_1_name, prompt_1, final_prompt_1, sms_1,
        model_2_name, prompt_2, final_prompt_2, sms_2,
        chosen_sms="sms_2"
    )
    return "Предпочтение SMS 2 сохранено в GitHub"

def save_sms_to_db(
    selected_product,
    description,
    product_name,
    benefits,
    key_message,
    gender,
    generation,
    psychotype,
    business_stage,
    industry,
    opf,
    chosen_approach,
    presence_in_db,
    model_name,
    prompt_text,
    final_prompt,  # добавили финальный промпт
    sms_text,
    comment_sms,
    corrected_sms
):
    data_to_save = {
        "timestamp": time.time(),
        "product_dropdown": selected_product,
        "description": description,
        "product_name": product_name,
        "benefits": benefits,
        "key_message": key_message,
        "gender": gender,
        "generation": generation,
        "psychotype": psychotype,
        "business_stage": business_stage,
        "industry": industry,
        "opf": opf,
        "chosen_approach": chosen_approach,
        "comment": presence_in_db,
        "model": model_name,
        "prompt": prompt_text,
        "final_prompt": final_prompt,   # сохраняем финальный промпт
        "sms": sms_text,
        "comment_sms": comment_sms,
        "corrected_sms": corrected_sms
    }

    file_content_encoded = base64.b64encode(json.dumps(data_to_save).encode()).decode()
    filename = f"saved_sms_{int(time.time())}.json"
    url = f"https://api.github.com/repos/{repo}/contents/{filename}"
    headers = {
        "Authorization": f"token {token}",
        "Content-Type": "application/json"
    }
    data = {
        "message": f"Добавлен файл {filename} со сведениями о сохранённом SMS",
        "content": file_content_encoded
    }
    resp = requests.put(url, headers=headers, data=json.dumps(data))
    if resp.status_code == 201:
        print(f"Файл {filename} успешно сохранён (save_sms_to_db).")
    else:
        print(f"Ошибка при сохранении (save_sms_to_db): {resp.status_code}, {resp.text}")

def on_save_sms_1(
    selected_product,
    description,
    product_name,
    benefits,
    key_message,
    gender,
    generation,
    psychotype,
    business_stage,
    industry,
    opf,
    chosen_approach,
    presence_in_db,
    model_1_name,
    prompt_1,
    final_prompt_1,
    sms_1,
    comment_sms_1,
    corrected_sms_1
):
    save_sms_to_db(
        selected_product=selected_product,
        description=description,
        product_name=product_name,
        benefits=benefits,
        key_message=key_message,
        gender=gender,
        generation=generation,
        psychotype=psychotype,
        business_stage=business_stage,
        industry=industry,
        opf=opf,
        chosen_approach=chosen_approach,
        presence_in_db=presence_in_db,
        model_name=model_1_name,
        prompt_text=prompt_1,
        final_prompt=final_prompt_1,
        sms_text=sms_1,
        comment_sms=comment_sms_1,
        corrected_sms=corrected_sms_1
    )
    return "SMS 1 сохранено в базу"

def on_save_sms_2(
    selected_product,
    description,
    product_name,
    benefits,
    key_message,
    gender,
    generation,
    psychotype,
    business_stage,
    industry,
    opf,
    chosen_approach,
    presence_in_db,
    model_2_name,
    prompt_2,
    final_prompt_2,
    sms_2,
    comment_sms_2,
    corrected_sms_2
):
    save_sms_to_db(
        selected_product=selected_product,
        description=description,
        product_name=product_name,
        benefits=benefits,
        key_message=key_message,
        gender=gender,
        generation=generation,
        psychotype=psychotype,
        business_stage=business_stage,
        industry=industry,
        opf=opf,
        chosen_approach=chosen_approach,
        presence_in_db=presence_in_db,
        model_name=model_2_name,
        prompt_text=prompt_2,
        final_prompt=final_prompt_2,
        sms_text=sms_2,
        comment_sms=comment_sms_2,
        corrected_sms=corrected_sms_2
    )
    return "SMS 2 сохранено в базу"

def prepare_button_text():
    return gr.update(value="Сохраняется...", visible=True)

def update_button_text():
    return gr.update(value="Сохранено!", visible=True)

def reset_button_text():
    time.sleep(2)
    return gr.update(value="Сохранить в базу", visible=True)

def reset_button_text_2():
    time.sleep(2)
    return gr.update(value="Я предпочитаю это SMS", visible=True)

# ФУНКЦИИ ПРОВЕРОК (НАЧАЛО)

# 1. Запрещенные слова

def check_forbidden_words(message):
    morph = pymorphy3.MorphAnalyzer()

    # Перечень запрещённых слов и фраз
    forbidden_patterns = [
        r'№\s?1\b', r'номер\sодин\b', r'номер\s1\b',
        r'вкусный', r'дешёвый', r'продукт',
        r'спам', r'банкротство', r'долг[и]?', r'займ',
        r'срочный', r'главный',
        r'гарантия', r'успех', r'лидер', 'никакой'
    ]

    # Удаляем знаки препинания для корректного анализа
    message_without_punctuation = message.translate(str.maketrans('', '', string.punctuation))

    # Замена всех слов, содержащих "бессроч", на временное значение
    placeholder = "заменабессроч"
    message_without_punctuation = re.sub(r'\b\w*бессроч\w*\b', placeholder, message_without_punctuation,
                                         flags=re.IGNORECASE)

    # Проверка на наличие подстроки "лучш" (без учета регистра)
    if re.search(r'лучш', message_without_punctuation, re.IGNORECASE):
        return (False, 'Есть слово "лучший"')

    # Лемматизация слов сообщения
    words = message_without_punctuation.split()
    lemmas = [morph.parse(word)[0].normal_form for word in words]

    # Восстановление всех слов с подстрокой "бессроч"
    lemmas = [re.sub(r'заменабессроч', 'бессроч', word) for word in lemmas]
    normalized_message = ' '.join(lemmas)

    # Проверка на запрещённые фразы и леммы
    for pattern in forbidden_patterns:
        if re.search(pattern, normalized_message, re.IGNORECASE):
            print(f"Не пройдена проверка: Запрещенные слова. Сообщение: {message}")
            return (False, f'Запрещенное слово: {pattern}')

    return True


# 2 и #3. Обращение к клиенту и приветствие клиента

def check_no_greeting(message):
    morph = pymorphy3.MorphAnalyzer()
    # Список типичных обращений и приветствий
    greeting_patterns = [
        r"привет\b", r"здравствуй", r"добрый\s(день|вечер|утро)",
        r"дорогой\b", r"уважаемый\b", r"дорогая\b", r"уважаемая\b",
        r"господин\b", r"госпожа\b", r"друг\b", r"коллега\b",
        r"товарищ\b", r"приятель\b", r"друг\b", r"подруга\b"
    ]

    # Компилируем все шаблоны в один регулярное выражение
    greeting_regex = re.compile('|'.join(greeting_patterns), re.IGNORECASE)

    # Проверяем, начинается ли сообщение с шаблона приветствия или обращения
    if greeting_regex.search(message.strip()):
        print(f"Не пройдена проверка: Обращение к клиенту и приветствие клиента. Сообщение: {message}")
        return (False, 'Есть приветствие')
    return True


# 4. Обещания и гарантии

def check_no_promises(message):
    morph = pymorphy3.MorphAnalyzer()
    promise_patterns = [
        "обещать", "обещание", "гарантировать", "обязаться", "обязать", "обязательство", "обязательный"
    ]

    words = message.split()
    lemmas = [morph.parse(word)[0].normal_form for word in words]

    for pattern in promise_patterns:
        if pattern in lemmas:
            print(f"Не пройдена проверка: Обещания и гарантии. Сообщение: {message}")
            return False, f'Не пройдена проверка: Обещания и гарантии:{pattern}'
    return True


# 5. Составные конструкции из двух глаголов

def check_no_double_verbs(message):
    morph = pymorphy3.MorphAnalyzer()
    # Разделяем текст по пробелам и знакам препинания
    words = re.split(r'\s+|[.!?]', message)
    morphs = [morph.parse(word)[0] for word in words]

    for i in range(len(morphs) - 1):
        # Проверяем, что оба слова являются глаголами (в любой форме, включая инфинитивы)
        if (morphs[i].tag.POS in {'VERB', 'INFN'}) and (morphs[i + 1].tag.POS in {'VERB', 'INFN'}):
            # Проверяем, является ли первый глагол "хотеть" или "начинать"
            if morphs[i].normal_form in ['хотеть', 'начинать', 'начать']:
                return True
            else:
                print(f"Не пройдена проверка: Составные конструкции из двух глаголов. Сообщение: {message}")
                return False, f'Не пройдена проверка на составные конструкции из двух глаголов: {morphs[i].word} {morphs[i + 1].word}'
    return True


# 6. Причастия и причастные обороты

def check_no_participles(message):
    morph = pymorphy3.MorphAnalyzer()
    words = message.split()
    exceptions = {"повысить", "увеличить", "понизить", "снизить"}

    for word in words:
        parsed_word = morph.parse(word)[0]
        lemma = parsed_word.normal_form
        if 'PRTF' in parsed_word.tag and lemma not in exceptions:
            print(f"Не пройдена проверка: Причастия и причастные обороты. Сообщение: {message}")
            return False, f'Не пройдена проверка на причастия: {parsed_word.word}'
    return True


# 7. Деепричастия и деепричастные обороты

def check_no_adverbial_participles(message):
    morph = pymorphy3.MorphAnalyzer()
    words = message.split()
    morphs = [morph.parse(word)[0] for word in words]

    for morph in morphs:
        if 'GRND' in morph.tag:
            print(f"Не пройдена проверка: Деепричастия и деепричастные обороты. Сообщение: {message}")
            return False, f'Не пройдена проверка на деепричастия: {morph.word}'
    return True


# 8. Превосходная степень прилагательных

def check_no_superlative_adjectives(message):
    morph = pymorphy3.MorphAnalyzer()
    words = message.split()
    morphs = [morph.parse(word)[0] for word in words]

    for morph in morphs:
        if 'Supr' in morph.tag:
            print(f"Не пройдена проверка: Превосходная степень прилагательных. Сообщение: {message}")
            return False, f'Не пройдена проверка на превосходную степерь прилагательного: {morph.word}'
    return True


# 9. Страдательный залог

def check_no_passive_voice(message):
    morph = pymorphy3.MorphAnalyzer()
    # Разбиваем сообщение на слова, игнорируя пунктуацию
    words = re.findall(r'\b\w+(?:-\w+)*\b', message.lower())

    for word in words:
        parse = morph.parse(word)[0]  # Берём только первый разбор
        if 'pssv' in parse.tag:
            return False, f'Не пройдена проверка на страдательный залог: {word}'
    return True


# 10. Порядковые числительные от 10 прописью

def check_no_written_out_ordinals(message):
    morph = pymorphy3.MorphAnalyzer()
    ordinal_words = [
        "десятый", "одиннадцатый", "двенадцатый", "тринадцатый", "четырнадцатый", "пятнадцатый",
        "шестнадцатый", "семнадцатый", "восемнадцатый", "девятнадцатый", "двадцатый"
    ]

    words = message.split()
    lemmas = [morph.parse(word)[0].normal_form for word in words]

    for word in ordinal_words:
        if word in lemmas:
            print(f"Не пройдена проверка: Порядковые числительные от 10 прописью. Сообщение: {message}")
            return False, f'Не пройдена проверка на порядковые числительные: {word}'
    return True


# 11. Цепочки с придаточными предложениями

def check_no_subordinate_clauses_chain(message):
    # Регулярное выражение, которое ищет последовательности придаточных предложений
    subordinate_clause_patterns = [
        r'\b(который|которая|которое|которые)\b',
        r'\b(если|потому что|так как|что|когда)\b',
        r'\b(хотя|несмотря на то что)\b'
    ]
    # Разделяем сообщение на предложения по точке, вопросительному и восклицательному знакам
    sentences = re.split(r'[.!?]\s*', message)

    count = 0
    for sentence in sentences:
        for pattern in subordinate_clause_patterns:
            if re.search(pattern, sentence):
                count += 1

    # Если в предложении найдено более одного придаточного предложения подряд, возвращаем False
    if count < 2:
        return True
    else:
        return False, f'Не пройдена проверка на цепочки с придаточными предложениями. Предложений: {count}'


# 12. Разделительные повторяющиеся союзы

def check_no_repeating_conjunctions(message):
    # Регулярное выражение для поиска разделительных повторяющихся союзов с запятой перед вторым союзом
    repeating_conjunctions_patterns = r'\b(и|ни|то|не то|или|либо)\b\s*(.*?)\s*,\s*\b\1\b'

    # Разделяем сообщение на предложения по точке, вопросительному и восклицательному знакам
    sentences = re.split(r'[.!?]\s*', message)

    # Проверяем каждое предложение отдельно
    for sentence in sentences:
        if re.search(repeating_conjunctions_patterns, sentence, re.IGNORECASE):
            print(f"Не пройдена проверка: Разделительные повторяющиеся союзы. Сообщение: {message}")
            return False, f'Не пройдена проверка на разделительные повторяющиеся союзы: {sentence}'
    return True


# 13. Вводные конструкции

def check_no_introductory_phrases(message):
    introductory_phrases = [
        r'\b(во-первых|во-вторых|с одной стороны|по сути|по правде говоря)\b',
        r'\b(может быть|кстати|конечно|естественно|безусловно|возможно)\b'
    ]

    for pattern in introductory_phrases:
        if re.search(pattern, message, re.IGNORECASE):
            print(f"Не пройдена проверка: Вводные конструкции. Сообщение: {message}")
            return False, f'Не пройдена проверка на вводные конструкции: {pattern}'
    return True


# 14. Усилители

def check_no_amplifiers(message):
    amplifiers = [
        r'\b(очень|крайне|чрезвычайно|совсем|полностью|чисто)\b'
    ]

    for pattern in amplifiers:
        if re.search(pattern, message, re.IGNORECASE):
            print(f"Не пройдена проверка: Усилители. Сообщение: {message}")
            return False, f"Не пройдена проверка на усилители: {pattern}"
    return True

# 15. Паразиты времени

def check_no_time_parasites(message):
    time_parasites = [
        r'\b(немедленно|срочно|в данный момент)\b'
    ]

    for pattern in time_parasites:
        if re.search(pattern, message, re.IGNORECASE):
            print(f"Не пройдена проверка: Паразиты времени. Сообщение: {message}")
            return False, f'Не пройдена проверка на паразитов времени: {pattern}'
    return True


# 16. Несколько существительных подряд

def check_no_multiple_nouns(message):
    noun_count = 0
    words = re.split(r'\s+|[.!?]', message)  # Разбиваем по пробелам и знакам препинания
    morph = pymorphy3.MorphAnalyzer()

    for word in range(len(words)):
        parsed_word = morph.parse(words[word])[0]

        # Если слово — существительное
        if 'NOUN' in parsed_word.tag:
            noun_count += 1
        # Если встречен конец предложения (точка, вопросительный знак, восклицательный знак)
        elif re.match(r'[.!?]', words[word]):
            noun_count = 0
        else:
            noun_count = 0

        if noun_count > 2:
            print(f"Не пройдена проверка: Несколько существительных подряд. Сообщение: {message}")
            return False, f'Не пройдена проверка на несколько существительных подряд: {words[word - 2: word + 1]}'
    return True


# 17. Производные предлоги

def check_no_derived_prepositions(message):
    derived_prepositions = [
        r'\b(в течение|в ходе|вследствие|в связи с|по мере|при помощи|согласно|вопреки|на основании|на случай|в продолжение|по причине|вблизи|вдалеке|вокруг|внутри|вдоль|посередине|вне|снаружи|благодаря|невзирая на|исходя из|благодаря)\b'
    ]

    for pattern in derived_prepositions:
        if re.search(pattern, message, re.IGNORECASE):
            print(f"Не пройдена проверка: Производные предлоги. Сообщение: {message}")
            return False, f"Не пройдена проверка на производные предлоги: {pattern}"
    return True


# 19. Сложноподчиненные предложения

def check_no_compound_sentences(message):
    subordinating_conjunctions = [
        r'\bкогда\b', r'\bкак только\b', r'\bпока\b', r'\bпосле того как\b',
        r'\bпотому что\b', r'\bтак как\b', r'\bоттого что\b', r'\bблагодаря тому что\b',
        r'\bчтобы\b', r'\bдля того чтобы\b', r'\bесли\b', r'\bкогда бы\b', r'\bесли бы\b',
        r'\bхотя\b', r'\bнесмотря на то что\b', r'\bкак\b', r'\bбудто\b', r'\bсловно\b', r'\bкак будто\b'
    ]

    # Убедимся, что слово "как" используется не в вопросе
    for pattern in subordinating_conjunctions:
        if re.search(pattern, message) and not re.search(r'\?', message):
            print(f"Не пройдена проверка: Сложноподчиненные предложения. Сообщение: {message}")
            return False, f"Не пройдена проверка: Сложноподчиненные предложения: {pattern}"
    return True


# 20. Даты прописью

def check_no_dates_written_out(message):
    # Ищем упоминания месяцев или слов, связанных с датами
    months = [
        "января", "февраля", "марта", "апреля", "мая", "июня",
        "июля", "августа", "сентября", "октября", "ноября", "декабря"
    ]

    # Слова для проверки чисел прописью
    date_written_out_patterns = [
        r'\b(первого|второго|третьего|четвертого|пятого|шестого|седьмого|восьмого|девятого|десятого|одиннадцатого|двенадцатого|тринадцатого|четырнадцатого|пятнадцатого|шестнадцатого|семнадцатого|восемнадцатого|девятнадцатого|двадцатого|двадцать первого|двадцать второго|двадцать третьего|двадцать четвертого|двадцать пятого|двадцать шестого|двадцать седьмого|двадцать восьмого|двадцать девятого|тридцатого|тридцать первого)\b'
    ]

    for month in months:
        for pattern in date_written_out_patterns:
            if re.search(f'{pattern}\\s{month}', message, re.IGNORECASE):
                print(f"Не пройдена проверка: Даты прописью. Сообщение: {message}")
                return False, f"Не пройдена проверка на даты прописью: {pattern}"

    return True

# Доп правило. Повторы слов

def check_no_word_repetitions(message, key_message):
    morph = pymorphy3.MorphAnalyzer()

    # Определяем набор частей речи, которые будем игнорировать
    ignore_pos = {
        'PREP',  # Предлоги
        'CONJ',  # Союзы
        'PRON',  # Местоимения
        'INTJ',  # Междометия
        'NUMR',  # Числительные
        'PART',  # Частицы
        'NPRO'
    }

    # Разбиваем текст на слова, учитывая составные слова с дефисом
    words = re.findall(r'\b\w+(?:-\w+)*\b', message.lower())

    # Функция для нормализации слов и получения их базовых форм
    def normalize_word(word):
        parses = morph.parse(word)
        if not parses:
            return word  # Если слово не распознано, возвращаем как есть
        parse = parses[0]
        return parse.normal_form, parse.tag.POS

    # Нормализуем ключевое сообщение и собираем его базовые формы
    key_normalized = set()
    for word in re.findall(r'\b\w+\b', key_message.lower()):
        norm, pos = normalize_word(word)
        key_normalized.add(norm)

    # Добавляем базовые формы ключевого сообщения в игнорируемые слова
    # Это позволяет игнорировать повторения слов из ключевого сообщения
    # Кроме того, игнорируем слова из определенных частей речи
    normalized_words = {}

    for word in words:
        norm, pos = normalize_word(word)

        # Игнорируем слово, если оно относится к одной из игнорируемых частей речи
        if pos in ignore_pos:
            continue

        # Игнорируем слово, если оно присутствует в ключевом сообщении
        if norm in key_normalized:
            continue

        # Если слово уже встречалось, возвращаем False
        if norm in normalized_words:
            print(f"Не пройдена проверка: Повторы слов. Сообщение: {message}")
            return False, f"Не пройдена проверка на повторы слов: {norm}"

        # Добавляем слово в словарь для отслеживания повторов
        normalized_words[norm] = True

    # Если повторов не найдено, возвращаем True
    return True

# ФУНКЦИИ ПРОВЕРОК (КОНЕЦ)

def cut_message(message: str):
    if '------' in message:
        message = message.split('------')[0].strip()
    return message

def safe_check(func, message, key_message=None):
    try:
        import inspect
        sig = inspect.signature(func)
        if len(sig.parameters) == 2:
            return func(message, key_message)
        else:
            return func(message)
    except Exception as e:
        return None

def perform_checks(message, key_message):
    checks = {
        "forbidden_words": safe_check(check_forbidden_words, message),
        "client_addressing": safe_check(check_no_greeting, message),
        "promises": safe_check(check_no_promises, message),
        "double_verbs": safe_check(check_no_double_verbs, message),
        "participles": safe_check(check_no_participles, message),
        "adverbial_participles": safe_check(check_no_adverbial_participles, message),
        "superlative_adjectives": safe_check(check_no_superlative_adjectives, message),
        "passive_voice": safe_check(check_no_passive_voice, message),
        "written_out_ordinals": safe_check(check_no_written_out_ordinals, message),
        "subordinate_clauses_chain": safe_check(check_no_subordinate_clauses_chain, message),
        "repeating_conjunctions": safe_check(check_no_repeating_conjunctions, message),
        "introductory_phrases": safe_check(check_no_introductory_phrases, message),
        "amplifiers": safe_check(check_no_amplifiers, message),
        "time_parasites": safe_check(check_no_time_parasites, message),
        "multiple_nouns": safe_check(check_no_multiple_nouns, message),
        "derived_prepositions": safe_check(check_no_derived_prepositions, message),
        "compound_sentences": safe_check(check_no_compound_sentences, message),
        "dates_written_out": safe_check(check_no_dates_written_out, message),
        "no_word_repetitions": safe_check(check_no_word_repetitions, message, key_message),
    }
    return checks

def format_checks(checks):
    translation = {
        "forbidden_words": "Запрещенные слова",
        "client_addressing": "Обращение к клиенту",
        "promises": "Обещания и гарантии",
        "double_verbs": "Два глагола подряд",
        "participles": "Причастия",
        "adverbial_participles": "Деепричастия",
        "superlative_adjectives": "Превосходная степень",
        "passive_voice": "Страдательный залог",
        "written_out_ordinals": "Порядковые числительные",
        "subordinate_clauses_chain": "Цепочки придаточных",
        "repeating_conjunctions": "Повторяющиеся союзы",
        "introductory_phrases": "Вводные конструкции",
        "amplifiers": "Усилители",
        "time_parasites": "Паразиты времени",
        "multiple_nouns": "Сущ. подряд",
        "derived_prepositions": "Производные предлоги",
        "compound_sentences": "Сложноподчиненные предложения",
        "dates_written_out": "Даты прописью",
        "no_word_repetitions": "Повторы слов"
    }
    formatted_results = []
    for rule, result in checks.items():
        if result is True:
            symbol = '✔️'
        elif result is False:
            symbol = '❌'
        else:
            symbol = '❓'
        formatted_results.append(f"{translation[rule]}: {symbol}")
    return "  \n".join(formatted_results)
    

with gr.Blocks(theme="default") as demo:
    gr.Markdown("**Процент созданных SMS по выбранному продукту**")
    progress_bar_html = """
    <div style="width: 100%; background-color: #e0e0e0; border-radius: 10px; overflow: hidden;">
        <div style="width: 0%; background-color: #4caf50; height: 20px; text-align: center; color: white;">
            0%
        </div>
    </div>
    """
    gr.HTML(progress_bar_html)
    with gr.Row():
        with gr.Column(scale=1):
            gr.Markdown("**Продукт**")
            product_dropdown = gr.Dropdown(label="Продукт", choices=products, value=products[0])
            description = gr.Textbox(label="Описание предложения", lines=5, value="", interactive=True)
            product_name = gr.Textbox(label="Наименование продукта", lines=1, value="", interactive=True)
            benefits = gr.Textbox(label="Преимущества", lines=9, value="", interactive=True)
            key_message = gr.Textbox(label="Ключевое сообщение", lines=2, value="")

            def on_product_change(selected, description, product_name, benefits, key_message,
                                  gender, generation, psychotype, business_stage, industry, opf):
                if selected == "Свой продукт":
                    new_desc = ""
                    new_pname = ""
                    new_ben = ""
                    new_kmsg = ""
                else:
                    if selected and selected in data_products["Наименование продукта"].values:
                        product_row = data_products[data_products["Наименование продукта"] == selected].iloc[0]
                        new_desc = product_row.get("Описание предложения", "")
                        new_pname = product_row.get("Наименование продукта", "")
                        new_ben = product_row.get("Преимущества", "")
                        new_kmsg = product_row.get("Ключевое сообщение", "")
                    else:
                        new_desc = ""
                        new_pname = ""
                        new_ben = ""
                        new_kmsg = ""
                chosen_approach_val, p1, p2 = update_prompts_on_params_change(new_desc, new_pname, new_ben, new_kmsg,
                                                                              gender, generation, psychotype,
                                                                              business_stage, industry, opf)
                return (gr.update(value=new_desc, interactive=(selected=="Свой продукт")),
                        gr.update(value=new_pname, interactive=(selected=="Свой продукт")),
                        gr.update(value=new_ben, interactive=(selected=="Свой продукт")),
                        gr.update(value=new_kmsg, interactive=(selected=="Свой продукт")),
                        chosen_approach_val, p1, p2,
                        "", "", "", "", "", "")

        with gr.Column(scale=1):
            gr.Markdown("**Клиент**")
            gender_dropdown = gr.Dropdown(label="Пол", choices=["Не выбрано"]+genders, value=None)
            generation_dropdown = gr.Dropdown(label="Поколение", choices=["Не выбрано"]+generations, value=None)
            psychotype_dropdown = gr.Dropdown(label="Психотип", choices=["Не выбрано"]+psychotypes, value=None)
            business_stage_dropdown = gr.Dropdown(label="Стадия бизнеса", choices=["Не выбрано"]+business_stages, value=None)
            industry_dropdown = gr.Dropdown(label="Отрасль", choices=["Не выбрано"]+industries, value=None)
            opf_dropdown = gr.Dropdown(label="ОПФ", choices=["Не выбрано"]+opfs, value=None)
            chosen_approach = gr.Textbox(label="Выбранный подход", lines=1, value="", interactive=False)
            presence_in_db = gr.Textbox(label="Комментарий", lines=1, value="", interactive=False)

    with gr.Row():
        return_params_btn = gr.Button("Вернуть параметры предыдущего запроса")
        set_unused_params_btn = gr.Button("Задать ранее невыставленные параметры (кнопка пока не работает)")
        create_personal_sms_btn = gr.Button("Создать персонализированное SMS")
    
    with gr.Row():
        with gr.Column():
            model_1_name = gr.Textbox(label="Модель 1", value="Grok-2-1212", interactive=False)
            prompt_1 = gr.Textbox(label="Промпт 1", value="", interactive=False, lines=10)
            sms_1 = gr.Textbox(label="SMS 1", lines=3, value="", interactive=False)
        
        with gr.Column():
            model_2_name = gr.Textbox(label="Модель 2", value="Grok-2-1212", interactive=False)
            prompt_2 = gr.Textbox(label="Промпт 2", value="", interactive=False, lines=10)
            sms_2 = gr.Textbox(label="SMS 2", lines=3, value="", interactive=False)
    
    with gr.Row():
        prefer_sms_1_btn = gr.Button("Я предпочитаю это SMS")
        prefer_sms_2_btn = gr.Button("Я предпочитаю это SMS")

    regen_btn = gr.Button("Перегенерировать SMS (не нравится ни одно из SMS)")
    
    with gr.Row():
        comment_sms_1 = gr.Textbox(label="Комментарий к SMS 1", lines=2, value="")
        comment_sms_2 = gr.Textbox(label="Комментарий к SMS 2", lines=2, value="")
    
    with gr.Row():
        corrected_sms_1 = gr.Textbox(label="Откорректированное SMS 1", lines=3, value="")
        corrected_sms_2 = gr.Textbox(label="Откорректированное SMS 2", lines=3, value="")
    
    with gr.Row():
        save_sms_1_btn = gr.Button("Сохранить в базу")
        save_sms_2_btn = gr.Button("Сохранить в базу")

    with gr.Row():
        checks_sms_1 = gr.Markdown()
        checks_sms_2 = gr.Markdown()

    final_prompt_1_state = gr.State("")
    final_prompt_2_state = gr.State("")

    product_dropdown.change(
        fn=on_product_change,
        inputs=[product_dropdown, description, product_name, benefits, key_message,
                gender_dropdown, generation_dropdown, psychotype_dropdown,
                business_stage_dropdown, industry_dropdown, opf_dropdown],
        outputs=[description, product_name, benefits, key_message,
                 chosen_approach, prompt_1, prompt_2,
                 sms_1, sms_2, comment_sms_1, comment_sms_2, corrected_sms_1, corrected_sms_2]
    )

    def params_change_wrapper(description, product_name, benefits, key_message,
                              gender, generation, psychotype, business_stage, industry, opf):
        chosen_approach_val, p1, p2 = update_prompts_on_params_change(description, product_name, benefits, key_message,
                                                                     gender, generation, psychotype,
                                                                     business_stage, industry, opf)
        return chosen_approach_val, p1, p2, "", "", "", "", "", ""

    client_params = [gender_dropdown, generation_dropdown, psychotype_dropdown,
                     business_stage_dropdown, industry_dropdown, opf_dropdown]
    for cp in client_params:
        cp.change(
            fn=params_change_wrapper,
            inputs=[description, product_name, benefits, key_message,
                    gender_dropdown, generation_dropdown, psychotype_dropdown,
                    business_stage_dropdown, industry_dropdown, opf_dropdown],
            outputs=[chosen_approach, prompt_1, prompt_2,
                     sms_1, sms_2, comment_sms_1, comment_sms_2, corrected_sms_1, corrected_sms_2]
        )

    create_personal_sms_btn.click(
        fn=generate_personalized_sms_wrapper,
        inputs=[product_dropdown, description, product_name, benefits, key_message, 
                gender_dropdown, generation_dropdown, psychotype_dropdown,
                business_stage_dropdown, industry_dropdown, opf_dropdown,
                chosen_approach, prompt_1, prompt_2],
        outputs=[sms_1, sms_2, final_prompt_1_state, final_prompt_2_state, checks_sms_1, checks_sms_2]
    )

    regen_btn.click(
        fn=on_regenerate,
        inputs=[
            product_dropdown,
            description,
            product_name,
            benefits,
            key_message,
            gender_dropdown,
            generation_dropdown,
            psychotype_dropdown,
            business_stage_dropdown,
            industry_dropdown,
            opf_dropdown,
            chosen_approach,
            presence_in_db,
            model_1_name,
            prompt_1,
            final_prompt_1_state,
            sms_1,
            model_2_name,
            prompt_2,
            final_prompt_2_state,
            sms_2
        ],
        outputs=[sms_1, sms_2, checks_sms_1, checks_sms_2]
    )

    return_params_btn.click(
        fn=on_load_previous,
        inputs=[],
        outputs=[product_dropdown, description, product_name, benefits, key_message,
                 gender_dropdown, generation_dropdown, psychotype_dropdown,
                 business_stage_dropdown, industry_dropdown, opf_dropdown,
                 chosen_approach, prompt_1, prompt_2,
                 sms_1, sms_2, comment_sms_1, comment_sms_2, corrected_sms_1, corrected_sms_2]
    )

    prefer_sms_1_btn.click(
        fn=prepare_button_text,
        inputs=[],
        outputs=[prefer_sms_1_btn]
    ).then(
        fn=on_prefer_sms_1,
        inputs=[
            product_dropdown,
            description,
            product_name,
            benefits,
            key_message,
            gender_dropdown,
            generation_dropdown,
            psychotype_dropdown,
            business_stage_dropdown,
            industry_dropdown,
            opf_dropdown,
            chosen_approach,
            presence_in_db,
            model_1_name,
            prompt_1,
            final_prompt_1_state,
            sms_1,
            model_2_name,
            prompt_2,
            final_prompt_2_state,
            sms_2
        ],
        outputs=[]  # или выводим что-то в текстбокс
    ).then(
        fn=update_button_text,
        inputs=[],
        outputs=[prefer_sms_1_btn]
    ).then(
        fn=reset_button_text_2,
        inputs=[],
        outputs=[prefer_sms_1_btn]
    )

    prefer_sms_2_btn.click(
        fn=prepare_button_text,
        inputs=[],
        outputs=[prefer_sms_2_btn]
    ).then(
        fn=on_prefer_sms_2,
        inputs=[
            product_dropdown,
            description,
            product_name,
            benefits,
            key_message,
            gender_dropdown,
            generation_dropdown,
            psychotype_dropdown,
            business_stage_dropdown,
            industry_dropdown,
            opf_dropdown,
            chosen_approach,
            presence_in_db,
            model_1_name,
            prompt_1,
            final_prompt_1_state,
            sms_1,
            model_2_name,
            prompt_2,
            final_prompt_2_state,
            sms_2
        ],
        outputs=[]  # или выводим что-то в текстбокс
    ).then(
        fn=update_button_text,
        inputs=[],
        outputs=[prefer_sms_2_btn]
    ).then(
        fn=reset_button_text_2,
        inputs=[],
        outputs=[prefer_sms_2_btn]
    )

    save_sms_1_btn.click(
        fn=prepare_button_text,
        inputs=[],
        outputs=[save_sms_1_btn]
    ).then(
        fn=on_save_sms_1,
        inputs=[
            product_dropdown,
            description,
            product_name,
            benefits,
            key_message,
            gender_dropdown,
            generation_dropdown,
            psychotype_dropdown,
            business_stage_dropdown,
            industry_dropdown,
            opf_dropdown,
            chosen_approach,
            presence_in_db,
            model_1_name,
            prompt_1,
            final_prompt_1_state,
            sms_1,
            comment_sms_1,
            corrected_sms_1
        ],
        outputs=[]
    ).then(
        fn=update_button_text,
        inputs=[],
        outputs=[save_sms_1_btn]
    ).then(
        fn=reset_button_text,
        inputs=[],
        outputs=[save_sms_1_btn]
    )

    save_sms_2_btn.click(
        fn=prepare_button_text,
        inputs=[],
        outputs=[save_sms_2_btn]
    ).then(
        fn=on_save_sms_2,
        inputs=[
            product_dropdown,
            description,
            product_name,
            benefits,
            key_message,
            gender_dropdown,
            generation_dropdown,
            psychotype_dropdown,
            business_stage_dropdown,
            industry_dropdown,
            opf_dropdown,
            chosen_approach,
            presence_in_db,
            model_2_name,
            prompt_2,
            final_prompt_2_state,
            sms_2,
            comment_sms_2,
            corrected_sms_2
        ],
        outputs=[]
    ).then(
        fn=update_button_text,
        inputs=[],
        outputs=[save_sms_2_btn]
    ).then(
        fn=reset_button_text,
        inputs=[],
        outputs=[save_sms_2_btn]
    )
    

    demo.queue().launch()