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):
    morph = pymorphy3.MorphAnalyzer()
    text = re.sub(r'\s[-–—]\s', ' — ', text)
    text = re.sub(r'(?<=\d)[-–—](?=\d)', '–', text)
    text = re.sub(r'(?<=[a-zA-Zа-яА-Я0-9])[-–—](?=[a-zA-Zа-яА-Я0-9])', '-', text)
    text = re.sub(r'"([^\"]+)"', r'«\1»', text)
    if text.count('"') == 1:
        text = text.replace('"', '')
    if (text.startswith('"') and text.endswith('"')) or (text.startswith('«') and text.endswith('»')):
        text = text[1:-1].strip()
    text = re.sub(r'(\d+)[kкКK]', r'\1 000', text, flags=re.IGNORECASE)
    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"
    ]

    def is_greeting_sentence(sentence):
        words = sentence.split()
        if len(words) < 5:
            for word in words:
                parsed = morph.parse(word.lower())[0]
                for pattern in greeting_patterns:
                    if re.search(pattern, parsed.normal_form):
                        return True
        return False

    sentences = re.split(r'(?<=[.!?])\s+', text)
    if sentences and is_greeting_sentence(sentences[0]):
        sentences = sentences[1:]
    text = ' '.join(sentences)

    def restore_yo(text):
        morph = pymorphy3.MorphAnalyzer()
        words = text.split()
        restored_words = []
        for word in words:
            if word.isupper():
                restored_words.append(word)
                continue
            if word.lower() == "все":
                restored_words.append(word)
                continue
            parsed = morph.parse(word)[0]
            restored_word = parsed.word
            if word and word[0].isupper():
                restored_word = restored_word.capitalize()
            restored_words.append(restored_word)
        return ' '.join(restored_words)

    text = restore_yo(text)
    text = re.sub(r'\bИп\b', 'ИП', text, flags=re.IGNORECASE)
    text = re.sub(r'\bОоо\b', 'ООО', text, flags=re.IGNORECASE)
    text = re.sub(r'\bРф\b', 'РФ', text, flags=re.IGNORECASE)
    text = re.sub(r'\bпользовуйтесь\b', 'пользуйтесь', text, flags=re.IGNORECASE)
    text = re.sub(r'\bею\b', 'ей', text, flags=re.IGNORECASE)
    text = re.sub(r'\bповышьте\b', 'повысьте', text, flags=re.IGNORECASE)
    text = re.sub(r'\bСбербизнес\b', 'СберБизнес', text, flags=re.IGNORECASE)
    text = re.sub(r'\bСбербизнеса\b', 'СберБизнес', text, flags=re.IGNORECASE)
    text = re.sub(r'\bСбербизнесе\b', 'СберБизнес', text, flags=re.IGNORECASE)
    text = re.sub(r'\bСбербанк\b', 'СберБанк', text, flags=re.IGNORECASE)
    text = re.sub(r'\bвашего ООО\b', 'вашей компании', text, flags=re.IGNORECASE)
    text = re.sub(r'\b0₽\b', '0 р', text, flags=re.IGNORECASE)
    text = re.sub(r'\b₽\b', 'р', text, flags=re.IGNORECASE)
    text = re.sub(r'\bруб\.(?=\W|$)', 'р', text, flags=re.IGNORECASE)
    text = re.sub(r'\bруб(?:ля|лей)\b', 'р', text, flags=re.IGNORECASE)
    text = re.sub(r'(\d+)\s+тысяч(?:а|и)?(?:\s+рублей)?', r'\1 000 р', text, flags=re.IGNORECASE)
    text = re.sub(r'(\d+)\s*тыс\.\s*руб\.', r'\1 000 р', text, flags=re.IGNORECASE)
    text = re.sub(r'(\d+)\s*тыс\.\s*р\.', r'\1 000 р', text, flags=re.IGNORECASE)
    text = re.sub(r'(\d+)\s*тыс\.\s*р', r'\1 000 р', text, flags=re.IGNORECASE)
    text = re.sub(r'(\d+)\s+миллиона\b|\bмиллионов\b', r'\1 млн', text, flags=re.IGNORECASE)
    text = re.sub(r'(\d+)\s*млн\s*руб\.', r'\1 млн р', text, flags=re.IGNORECASE)
    text = re.sub(r'(\d+)\s*р\b', r'\1 р', text)

    def remove_specific_sentences(text):
        sentences = re.split(r'(?<=[.!?])\s+', text)
        filtered_sentences = [
            sentence for sentence in sentences
            if not re.search(r'\bникаких\s+(посещений|визитов)\b', sentence, re.IGNORECASE)
        ]
        return ' '.join(filtered_sentences)

    text = re.sub(r'\b(\d+)\s+000\s+000\s*р\b', r'\1 млн р', text, flags=re.IGNORECASE)
    text = re.sub(r' р р ', r' р ', text, flags=re.IGNORECASE)
    text = remove_specific_sentences(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):
    source_report, exceptions_dict = check_source_fields(description, product_name, benefits, key_message)
    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, exceptions_dict)
    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, exceptions_dict)
    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)

def check_source_fields(description, product_name, benefits, key_message):
    results = []
    exceptions_dict = {
        "forbidden_words": set(),
        "greetings": set(),
        "promises": set(),
        "double_verbs": set(),
        "participles": set(),
        "adverbial_participles": set(),
        "superlative_adjectives": set(),
        "passive_voice": set(),
        "written_out_ordinals": set(),
        "repeating_conjunctions": set(),
        "introductory_phrases": set(),
        "amplifiers": set(),
        "time_parasites": set(),
        "multiple_nouns": set(),
        "derived_prepositions": set(),
        "compound_sentences": set(),
        "dates_written_out": set(),
        "word_repetitions": set()
    }

    # Проверяем "Описание предложения"
    desc_checks = perform_checks(description, "")
    not_passed_desc = extract_failed_checks(desc_checks, exceptions_dict, context="Описание предложения")
    if not_passed_desc:
        results.append(f"Описание предложения:\n{not_passed_desc}")

    # Проверяем "Наименование продукта"
    name_checks = perform_checks(product_name, "")
    not_passed_name = extract_failed_checks(name_checks, exceptions_dict, context="Наименование продукта")
    if not_passed_name:
        results.append(f"Наименование продукта:\n{not_passed_name}")

    # Проверяем "Преимущества"
    ben_checks = perform_checks(benefits, "")
    not_passed_ben = extract_failed_checks(ben_checks, exceptions_dict, context="Преимущества")
    if not_passed_ben:
        results.append(f"Преимущества:\n{not_passed_ben}")

    # Проверяем "Ключевое сообщение"
    km_checks = perform_checks(key_message, "")
    not_passed_km = extract_failed_checks(km_checks, exceptions_dict, context="Ключевое сообщение")
    if not_passed_km:
        results.append(f"Ключевое сообщение:\n{not_passed_km}")

    if not results:
        return "Проверка исходных данных пройдена", exceptions_dict
    else:
        report = "\n\n".join(results)
        return report, exceptions_dict


def on_check_source_fields(description, product_name, benefits, key_message):
    report, exceptions_dict = check_source_fields(description, product_name, benefits, key_message)
    return report


def extract_failed_checks(checks_dict, exceptions_dict, context=""):
    """
    Пробегаемся по результатам checks_dict.
    Если есть (False, reason), выводим reason, 
    и при необходимости парсим reason, чтобы добавить исключения в exceptions_dict.
    """
    import re
    import pymorphy3
    morph = pymorphy3.MorphAnalyzer()

    lines = []

    def lemma_pair(word1, word2):
        p1 = morph.parse(word1)[0].normal_form
        p2 = morph.parse(word2)[0].normal_form
        return (p1, p2)

    for rule_key, result in checks_dict.items():
        if isinstance(result, tuple):
            passed, reason = result
            if not passed:
                lines.append(f"{rule_to_str(rule_key)}: {reason}")
                # Пример: если rule_key == "double_verbs"
                if rule_key == "double_verbs":
                    # Ищем "...: 2 глагола подряд: позволяет зачислять"
                    # Допустим reason = "Не пройдена проверка на 2 глагола подряд: позволяет зачислять"
                    match = re.search(r'2 глагола подряд:\s*(\S+)\s+(\S+)$', reason)
                    if match:
                        w1 = match.group(1)
                        w2 = match.group(2)
                        pair_lemma = lemma_pair(w1, w2)
                        exceptions_dict.setdefault("double_verbs", set()).add(pair_lemma)

                elif rule_key == "forbidden_words":
                    # reason вроде: "Запрещенное слово: продукт"
                    match = re.search(r'Запрещенное слово:\s*(\S+)', reason)
                    if match:
                        w = match.group(1)
                        l, _ = lemmatize_word(w, morph)
                        exceptions_dict.setdefault("forbidden_words", set()).add(l)

                elif rule_key == "client_addressing":
                    # reason вроде: "Есть приветствие: дорогая"
                    match = re.search(r'приветствие:\s*(\S+)', reason, re.IGNORECASE)
                    if match:
                        w = match.group(1)
                        l, _ = lemmatize_word(w, morph)
                        exceptions_dict.setdefault("greetings", set()).add(l)

                elif rule_key == "promises":
                    # reason напр. "Не пройдена проверка: обещания => обещать"
                    match = re.search(r'=>\s*(\S+)$', reason)
                    if match:
                        patt = match.group(1)
                        exceptions_dict.setdefault("promises", set()).add(patt)

                elif rule_key == "participles":
                    # reason "Не пройдена проверка на причастие: повышающий"
                    match = re.search(r'причастие:\s*(\S+)$', reason)
                    if match:
                        w = match.group(1)
                        l, _ = lemmatize_word(w, morph)
                        exceptions_dict.setdefault("participles", set()).add(l)

                elif rule_key == "adverbial_participles":
                    # reason: "деепричастие => рассматривая"
                    match = re.search(r'деепричастие\s*=>\s*(\S+)$', reason)
                    if match:
                        w = match.group(1)
                        l, _ = lemmatize_word(w, morph)
                        exceptions_dict.setdefault("adverbial_participles", set()).add(l)

                elif rule_key == "superlative_adjectives":
                    # reason: "Не пройдена проверка на превосходную степень: сильнейший"
                    match = re.search(r'превосходную степень:\s*(\S+)$', reason)
                    if match:
                        w = match.group(1)
                        l, _ = lemmatize_word(w, morph)
                        exceptions_dict.setdefault("superlative_adjectives", set()).add(l)

                elif rule_key == "passive_voice":
                    # reason: "Страдательный залог: построен"
                    match = re.search(r'страдательный залог:\s*(\S+)$', reason)
                    if match:
                        w = match.group(1)
                        l, _ = lemmatize_word(w, morph)
                        exceptions_dict.setdefault("passive_voice", set()).add(l)

                elif rule_key == "written_out_ordinals":
                    # reason: "Порядковые числительные: десятый"
                    match = re.search(r'порядковые числительные:\s*(\S+)$', reason)
                    if match:
                        w = match.group(1)
                        exceptions_dict.setdefault("written_out_ordinals", set()).add(w)

                elif rule_key == "repeating_conjunctions":
                    # reason: "Повторяющиеся союзы: ...", 
                    match = re.search(r'союзы:\s*(\S+)', reason)

                elif rule_key == "introductory_phrases":
                    match = re.search(r'конструкции:\s*(\S+)$', reason)
                    if match:
                        phrase = match.group(1).lower()
                        exceptions_dict.setdefault("introductory_phrases", set()).add(phrase)

                elif rule_key == "amplifiers":
                    # reason: "Не пройдена проверка на усилители: очень"
                    match = re.search(r'усилители:\s*(\S+)$', reason)
                    if match:
                        w = match.group(1)
                        l, _ = lemmatize_word(w, morph)
                        exceptions_dict.setdefault("amplifiers", set()).add(l)

                elif rule_key == "time_parasites":
                    # reason: "Не пройдена проверка на паразитов времени: срочно"
                    match = re.search(r'времени:\s*(\S+)$', reason)
                    if match:
                        w = match.group(1)
                        l, _ = lemmatize_word(w, morph)
                        exceptions_dict.setdefault("time_parasites", set()).add(l)

                elif rule_key == "multiple_nouns":
                    # reason: "Несколько существительных подряд: ('зачисление','зарплата','сотрудникам')"
                    match = re.search(r'подряд:\s*(\([^)]+\))', reason)
                    if match:
                        chain_str = match.group(1)  # "('зачисление','зарплата','сотрудникам')"
                        try:
                            chain_tuple = eval(chain_str)
                            exceptions_dict.setdefault("multiple_nouns", set()).add(chain_tuple)
                        except:
                            pass

                elif rule_key == "derived_prepositions":
                    # reason: "Не пройдена проверка на производные предлоги: благодаря"
                    match = re.search(r'предлоги:\s*(\S+)$', reason)
                    if match:
                        w = match.group(1).lower()
                        exceptions_dict.setdefault("derived_prepositions", set()).add(w)

                elif rule_key == "compound_sentences":
                    # reason может выглядеть так:
                    # "Не пройдена проверка: Сложноподчиненные предложения: как только"
                    # Разделим по двоеточию:
                    splitted = reason.split(': ', 2)
                    # splitted может быть ["Не пройдена проверка", "Сложноподчиненные предложения", "как только"]
                    if len(splitted) == 3:
                        raw_substring = splitted[2].strip()
                        # Добавляем сырую подстроку (без лемматизации) в исключения
                        exceptions_dict["compound_sentences"].add(raw_substring)

                elif rule_key == "dates_written_out":
                    # reason: "Не пройдена проверка на даты прописью: пятнадцатого июля"
                    match = re.search(r'даты прописью:\s*(.+)$', reason)
                    if match:
                        full = match.group(1).strip()
                        splitted = full.split()
                        if len(splitted) == 2:
                            ord_str, month_str = splitted
                            l_o, _ = lemmatize_word(ord_str, morph)
                            l_m, _ = lemmatize_word(month_str, morph)
                            pair = (l_o, l_m)
                            exceptions_dict.setdefault("dates_written_out", set()).add(pair)

                elif rule_key == "no_word_repetitions":  
                    # reason: "Не пройдена проверка на повторы слов: зачисление"
                    match = re.search(r'повторы слов:\s*(\S+)', reason, re.IGNORECASE)
                    if match:
                        rep_w = match.group(1)
                        l, _ = lemmatize_word(rep_w, morph)
                        exceptions_dict.setdefault("word_repetitions", set()).add(l)

        elif result is False:
            # Нет причины
            lines.append(f"{rule_to_str(rule_key)}: (без пояснения)")

    return "\n".join(lines)


def rule_to_str(rule_key):
    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": "Повторы слов",
    }
    return translation.get(rule_key, rule_key)


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

def lemmatize_word(word, morph):
    """
    Возвращает (lemma, POS) для переданного слова.
    """
    parsed = morph.parse(word)
    if not parsed:
        return word, None
    best = parsed[0]
    return best.normal_form, best.tag.POS

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

def check_forbidden_words(message, exceptions=None):
    """
    Проверка на запрещённые слова.
    Если лемма «запрещённого слова» находится в exceptions['forbidden_words'], 
    то пропускаем.
    """
    if exceptions is None:
        exceptions = {}
    allowed_lemmas = exceptions.get("forbidden_words", set())

    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_no_punct = message.translate(str.maketrans('', '', string.punctuation))

    # Пример: «бессроч» => placeholder
    placeholder = "заменабессроч"
    message_no_punct = re.sub(r'\b\w*бессроч\w*\b', placeholder, message_no_punct, flags=re.IGNORECASE)

    # Лемматизируем все слова
    words = message_no_punct.split()
    lemmas = [morph.parse(w)[0].normal_form for w in words]
    lemmas = [re.sub(r'заменабессроч', 'бессроч', l) for l in lemmas]
    normalized_msg = ' '.join(lemmas)

    # Для каждого pattern проверяем, нет ли совпадения
    for pattern in forbidden_patterns:
        found = re.search(pattern, normalized_msg, re.IGNORECASE)
        if found:
            # Получим саму найденную строку
            matched_str = found.group(0)
            # Лемматизируем
            lemma_found, _ = lemmatize_word(matched_str, morph)
            if lemma_found not in allowed_lemmas:
                return False, f"Запрещенное слово: {matched_str}"

    return True


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

def check_no_greeting(message, exceptions=None):
    """
    Проверка на «приветствия».
    Если лемма слова среди exceptions['greetings'], пропускаем.
    """
    if exceptions is None:
        exceptions = {}
    allowed_lemmas = exceptions.get("greetings", set())

    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"
    ]
    # Будем искать все совпадения паттернов
    for pat in greeting_patterns:
        match = re.search(pat, message, re.IGNORECASE)
        if match:
            found = match.group(0).lower()  # «дорогая», «привет» и т.п.
            morph = pymorphy3.MorphAnalyzer()
            lemma, pos = lemmatize_word(found, morph)
            if lemma not in allowed_lemmas:
                return False, f"Есть приветствие: {found}"
    return True


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

def check_no_promises(message, exceptions=None):
    """
    Проверка на «обещания».
    Если lemma слова в exceptions['promises'], то пропускаем.
    """
    if exceptions is None:
        exceptions = {}
    allowed_lemmas = exceptions.get("promises", set())

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

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

    for patt in patterns:
        if patt in lemmas:
            if patt not in allowed_lemmas:
                return False, f"Не пройдена проверка: обещания => {patt}"
    return True


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

def check_no_double_verbs(message, exceptions=None):
    """
    Проверка на 2 подряд глагола.
    Если (lemma1, lemma2) находится в exceptions['double_verbs'], то разрешаем.
    """
    if exceptions is None:
        exceptions = {}
    allowed_pairs = exceptions.get("double_verbs", set())

    morph = pymorphy3.MorphAnalyzer()
    words = re.split(r'\s+|[.!?]', message)

    tokens = [w.strip() for w in words if w.strip()]
    parses = [morph.parse(tok)[0] for tok in tokens]

    for i in range(len(parses) - 1):
        if (parses[i].tag.POS in {'VERB', 'INFN'}) and (parses[i+1].tag.POS in {'VERB', 'INFN'}):
            lemma1 = parses[i].normal_form
            lemma2 = parses[i+1].normal_form
            pair = (lemma1, lemma2)
            # Если разрешено
            if pair in allowed_pairs:
                continue
            # Если это "хотеть", "начинать", ...
            if lemma1 in ["хотеть", "начинать", "начать"]:
                continue
            return False, f"Не пройдена проверка на 2 глагола подряд: {parses[i].word} {parses[i+1].word}"
    return True


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

def check_no_participles(message, exceptions=None):
    """
    Проверка на причастия.
    Если lemma причастия в exceptions['participles'], разрешаем.
    """
    if exceptions is None:
        exceptions = {}
    allowed_lemmas = exceptions.get("participles", set())

    skip_lemmas = {"повысить", "увеличить", "понизить", "снизить"}

    morph = pymorphy3.MorphAnalyzer()
    words = message.split()

    for w in words:
        p = morph.parse(w)[0]
        lemma = p.normal_form
        if 'PRTF' in p.tag:
            # Проверяем исключения
            if lemma not in skip_lemmas and lemma not in allowed_lemmas:
                return False, f"Не пройдена проверка на причастие: {p.word}"
    return True


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

def check_no_adverbial_participles(message, exceptions=None):
    """
    Проверка на деепричастия. 
    Если lemma в exceptions['adverbial_participles'], то не считаем нарушением.
    """
    if exceptions is None:
        exceptions = {}
    allowed_lemmas = exceptions.get("adverbial_participles", set())

    morph = pymorphy3.MorphAnalyzer()
    words = message.split()
    for w in words:
        p = morph.parse(w)[0]
        lemma = p.normal_form
        if "GRND" in p.tag:
            if lemma not in allowed_lemmas:
                return False, f"Не пройдена проверка: деепричастие => {p.word}"
    return True


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

def check_no_superlative_adjectives(message, exceptions=None):
    """
    Проверка на превосходную степень прилагательных.
    Если lemma прилагательного среди exceptions['superlative_adjectives'], разрешаем.
    """
    if exceptions is None:
        exceptions = {}
    allowed_lemmas = exceptions.get("superlative_adjectives", set())

    morph = pymorphy3.MorphAnalyzer()
    for w in message.split():
        p = morph.parse(w)[0]
        lemma = p.normal_form
        if 'Supr' in p.tag:
            if lemma not in allowed_lemmas:
                return False, f"Не пройдена проверка на превосходную степень: {p.word}"
    return True


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

def check_no_passive_voice(message, exceptions=None):
    """
    Проверка на страдательный залог.
    Если lemma в exceptions['passive_voice'], пропускаем.
    """
    if exceptions is None:
        exceptions = {}
    allowed_lemmas = exceptions.get("passive_voice", set())

    morph = pymorphy3.MorphAnalyzer()
    words = re.findall(r'\b\w+(?:-\w+)*\b', message.lower())

    for w in words:
        p = morph.parse(w)[0]
        lemma = p.normal_form
        if 'pssv' in p.tag:
            if lemma not in allowed_lemmas:
                return False, f"Не пройдена проверка на страдательный залог: {w}"
    return True


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

def check_no_written_out_ordinals(message, exceptions=None):
    """
    Проверка на порядковые числительные, написанные прописью (десятый и т.д.).
    Если lemma в exceptions['written_out_ordinals'], пропускаем.
    """
    if exceptions is None:
        exceptions = {}
    allowed_lemmas = exceptions.get("written_out_ordinals", set())

    morph = pymorphy3.MorphAnalyzer()
    ordinal_words = [
        "десятый", "одиннадцатый", "двенадцатый", "тринадцатый",
        "четырнадцатый", "пятнадцатый", "шестнадцатый", "семнадцатый",
        "восемнадцатый", "девятнадцатый", "двадцатый"
    ]
    tokens = message.split()
    lemmas = [morph.parse(t)[0].normal_form for t in tokens]
    for ow in ordinal_words:
        if ow in lemmas:
            if ow not in allowed_lemmas:
                return False, f"Не пройдена проверка на порядковые числительные: {ow}"
    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, exceptions=None):
    """
    Проверка на повторяющиеся союзы 'и', 'или' и т.п.
    Если сам союз (в лемме) в exceptions['repeating_conjunctions'], пропускаем.
    """
    if exceptions is None:
        exceptions = {}
    allowed_conjs = exceptions.get("repeating_conjunctions", set())

    pattern = re.compile(r'\b(и|ни|то|не то|или|либо)\b\s*(.*?)\s*,\s*\b\1\b', re.IGNORECASE)
    sentences = re.split(r'[.!?]\s*', message)
    for s in sentences:
        m = pattern.search(s)
        if m:
            conj = m.group(1).lower()
            if conj not in allowed_conjs:
                return False, f"Не пройдена проверка на повторяющиеся союзы: {s}"
    return True


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

def check_no_introductory_phrases(message, exceptions=None):
    """
    Проверка на вводные конструкции.
    Если exact фраза в exceptions['introductory_phrases'], пропускаем.
    """
    if exceptions is None:
        exceptions = {}
    allowed_phrases = exceptions.get("introductory_phrases", set())

    patterns = [
        r'\b(во-первых|во-вторых|с одной стороны|по сути|по правде говоря)\b',
        r'\b(может быть|кстати|конечно|естественно|безусловно|возможно)\b'
    ]
    for pat in patterns:
        match = re.search(pat, message, re.IGNORECASE)
        if match:
            found = match.group(1).lower()
            if found not in allowed_phrases:
                return False, f"Не пройдена проверка на вводные конструкции: {found}"
    return True


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

def check_no_amplifiers(message, exceptions=None):
    """
    Проверка на усилители (очень, крайне...).
    Если лемма в exceptions['amplifiers'], пропускаем.
    """
    if exceptions is None:
        exceptions = {}
    allowed_lemmas = exceptions.get("amplifiers", set())

    pattern = re.compile(r'\b(очень|крайне|чрезвычайно|совсем|полностью|чисто)\b', re.IGNORECASE)
    matches = pattern.findall(message)
    if matches:
        morph = pymorphy3.MorphAnalyzer()
        for m in matches:
            lemma, _ = lemmatize_word(m, morph)
            if lemma not in allowed_lemmas:
                return False, f"Не пройдена проверка на усилители: {m}"
    return True

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

def check_no_time_parasites(message, exceptions=None):
    """
    Проверка на «паразиты времени» (немедленно, срочно...).
    Если лемма в exceptions['time_parasites'], пропускаем.
    """
    if exceptions is None:
        exceptions = {}
    allowed_lemmas = exceptions.get("time_parasites", set())

    pattern = re.compile(r'\b(немедленно|срочно|в данный момент)\b', re.IGNORECASE)
    matches = pattern.findall(message)
    if matches:
        morph = pymorphy3.MorphAnalyzer()
        for m in matches:
            lemma, _ = lemmatize_word(m, morph)
            if lemma not in allowed_lemmas:
                return False, f"Не пройдена проверка на паразитов времени: {m}"
    return True


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

def check_no_multiple_nouns(message, exceptions=None):
    """
    Проверка на 3+ подряд существительных.
    Если конкретная цепочка лемм в exceptions['multiple_nouns'], пропускаем.
    """
    if exceptions is None:
        exceptions = {}
    allowed_chains = exceptions.get("multiple_nouns", set())  # set of tuples

    morph = pymorphy3.MorphAnalyzer()
    tokens = re.split(r'[,\s.!?;:()]+', message)
    chain = []
    count = 0

    for t in tokens:
        t = t.strip()
        if not t:
            continue
        p = morph.parse(t)[0]
        lemma = p.normal_form
        if 'NOUN' in p.tag:
            count += 1
            chain.append(lemma)
        else:
            count = 0
            chain = []

        if count > 2:
            chain_tuple = tuple(chain)  # например ('зачисление', 'зарплата', 'сотрудникам')
            if chain_tuple not in allowed_chains:
                return False, f"Несколько существительных подряд: {chain_tuple}"
    return True


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

def check_no_derived_prepositions(message, exceptions=None):
    """
    Проверка на производные предлоги. 
    Если конкретный предлог в exceptions['derived_prepositions'], пропускаем.
    """
    if exceptions is None:
        exceptions = {}
    allowed_preps = exceptions.get("derived_prepositions", set())

    pattern_text = (r'\b(в течение|в ходе|вследствие|в связи с|по мере|при помощи|'
                    r'согласно|вопреки|на основании|на случай|в продолжение|по причине|'
                    r'вблизи|вдалеке|вокруг|внутри|вдоль|посередине|вне|снаружи|'
                    r'благодаря|невзирая на|исходя из|благодаря)\b')
    pat = re.compile(pattern_text, re.IGNORECASE)

    matches = pat.findall(message)
    if matches:
        for m in matches:
            low = m.lower()
            if low not in allowed_preps:
                return False, f"Не пройдена проверка на производные предлоги: {m}"
    return True


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

def check_no_compound_sentences(message, exceptions=None):
    """
    Проверка на отсутствие сложноподчиненных предложений.
    Если обнаружен союз/слово, которое есть в exceptions["compound_sentences"], 
    — НЕ считаем ошибкой.
    Если нет в исключениях, считаем ошибкой.
    """
    if exceptions is None:
        exceptions = {}

    # Список союзов/фраз, по которым мы определяем сложноподчинённость
    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'
    ]

    # Собираем «разрешённые» фразы (из исключений) – это сырые строки:
    allowed_raw_phrases = exceptions.get("compound_sentences", set())

    for pattern in subordinating_conjunctions:
        # Находим все вхождения союзов
        matches = re.finditer(pattern, message, re.IGNORECASE)
        for m in matches:
            raw_substring = m.group(0)  # «сырая» найденная строка
            # Если substring НЕ в наших исключениях:
            # (сравниваем без учёта регистра — можно .lower() )
            if raw_substring.lower() not in (s.lower() for s in allowed_raw_phrases):
                return (False, f'Не пройдена проверка: Сложноподчиненные предложения: {raw_substring}')

    return True


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

def check_no_dates_written_out(message, exceptions=None):
    """
    Проверка на даты прописью.
    Если (lemma_ordinal, lemma_month) в exceptions['dates_written_out'], пропускаем.
    """
    if exceptions is None:
        exceptions = {}
    allowed_dates = exceptions.get("dates_written_out", set())

    morph = pymorphy3.MorphAnalyzer()

    months = [
        "января", "февраля", "марта", "апреля", "мая", "июня",
        "июля", "августа", "сентября", "октября", "ноября", "декабря"
    ]
    date_patterns = [
        r'\b(первого|второго|третьего|четвертого|пятого|шестого|седьмого|'
        r'восьмого|девятого|десятого|одиннадцатого|двенадцатого|'
        r'тринадцатого|четырнадцатого|пятнадцатого|шестнадцатого|'
        r'семнадцатого|восемнадцатого|девятнадцатого|двадцатого|'
        r'двадцать первого|двадцать второго|двадцать третьего|'
        r'двадцать четвертого|двадцать пятого|двадцать шестого|'
        r'двадцать седьмого|двадцать восьмого|двадцать девятого|'
        r'тридцатого|тридцать первого)\b'
    ]

    for m in months:
        for patt in date_patterns:
            found = re.search(f"{patt}\\s{m}", message, re.IGNORECASE)
            if found:
                ordinal_str = found.group(1).lower()  # например «пятнадцатого»
                lemma_ord, _ = lemmatize_word(ordinal_str, morph)
                lemma_month, _ = lemmatize_word(m, morph)
                pair = (lemma_ord, lemma_month)  # («пятнадцатый», «июль»)
                if pair not in allowed_dates:
                    return False, f"Не пройдена проверка на даты прописью: {found.group(0)}"
    return True

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

def check_no_word_repetitions(message, key_message, exceptions=None):
    """
    Проверка на повторы слов (кроме определённых частей речи).
    Если lemma есть в exceptions['word_repetitions'], пропускаем.
    """
    if exceptions is None:
        exceptions = {}
    allowed_lemmas = exceptions.get("word_repetitions", set())

    morph = pymorphy3.MorphAnalyzer()
    ignore_pos = {'PREP', 'CONJ', 'PRON', 'INTJ', 'NUMR', 'PART', 'NPRO'}

    msg_words = re.findall(r'\b\w+(?:-\w+)*\b', message.lower())

    # Ключевое сообщение
    key_normalized = set()
    for kw in re.findall(r'\b\w+\b', key_message.lower()):
        lemma_k, pos_k = lemmatize_word(kw, morph)
        key_normalized.add(lemma_k)

    seen = {}
    for w in msg_words:
        lemma, pos = lemmatize_word(w, morph)
        if (not pos) or (pos in ignore_pos):
            continue
        if lemma in key_normalized:
            continue
        if lemma in allowed_lemmas:
            continue
        if lemma in seen:
            return False, f"Не пройдена проверка на повторы слов: {lemma}"
        seen[lemma] = 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:
        import traceback
        print(f"[ERROR in {func.__name__}]")
        traceback.print_exc()  # выведет traceback
        return None

def perform_checks(message, key_message, exceptions_dict=None):
    """
    Запускает все проверки для данного message. 
    exceptions_dict - словарь исключений:
        {
           "compound_sentences": set(...),
           "double_verbs": set(...),
           ...
        }
    и т.д.
    """
    checks = {
        "forbidden_words": safe_check(lambda msg, km: check_forbidden_words(msg, exceptions_dict), message),
        "client_addressing": safe_check(lambda msg, km: check_no_greeting(msg, exceptions_dict), message),
        "promises": safe_check(lambda msg, km: check_no_promises(msg, exceptions_dict), message),
        "double_verbs": safe_check(lambda msg, km: check_no_double_verbs(msg, exceptions_dict), message),
        "participles": safe_check(lambda msg, km: check_no_participles(msg, exceptions_dict), message),
        "adverbial_participles": safe_check(lambda msg, km: check_no_adverbial_participles(msg, exceptions_dict), message),
        "superlative_adjectives": safe_check(lambda msg, km: check_no_superlative_adjectives(msg, exceptions_dict), message),
        "passive_voice": safe_check(lambda msg, km: check_no_passive_voice(msg, exceptions_dict), message),
        "written_out_ordinals": safe_check(lambda msg, km: check_no_written_out_ordinals(msg, exceptions_dict), message),
        "subordinate_clauses_chain": safe_check(check_no_subordinate_clauses_chain, message),
        "repeating_conjunctions": safe_check(lambda msg, km: check_no_repeating_conjunctions(msg, exceptions_dict), message),
        "introductory_phrases": safe_check(lambda msg, km: check_no_introductory_phrases(msg, exceptions_dict), message),
        "amplifiers": safe_check(lambda msg, km: check_no_amplifiers(msg, exceptions_dict), message),
        "time_parasites": safe_check(lambda msg, km: check_no_time_parasites(msg, exceptions_dict), message),
        "multiple_nouns": safe_check(lambda msg, km: check_no_multiple_nouns(msg, exceptions_dict), message),
        "derived_prepositions": safe_check(lambda msg, km: check_no_derived_prepositions(msg, exceptions_dict), message),
        "compound_sentences": safe_check(lambda msg, km: check_no_compound_sentences(msg, exceptions_dict), message),
        "dates_written_out": safe_check(lambda msg, km: check_no_dates_written_out(msg, exceptions_dict), message),
        "no_word_repetitions": safe_check(lambda msg, km: check_no_word_repetitions(msg, km, exceptions_dict), 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": "Повторы слов"
    }

    lines = []
    for rule, result in checks.items():
        rule_name = translation.get(rule, rule)  # на случай, если нет в словаре
        # Если результат — кортеж (False, "причина")
        if isinstance(result, tuple):
            passed, msg = result
            if passed is True:
                symbol = "✔️"
            else:
                symbol = "❌"
        # Если результат — просто True/False
        elif result is True:
            symbol = "✔️"
        elif result is False:
            symbol = "❌"
        # Если None или что-то иное — ставим вопрос
        else:
            symbol = "❓"
        
        # Собираем строку вида: "Запрещенные слова: ✔️"
        lines.append(f"{rule_name}: {symbol}")

    return "  \n".join(lines)

    

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=3, value="", interactive=True)
            product_name = gr.Textbox(label="Наименование продукта", lines=1, value="", interactive=True)
            benefits = gr.Textbox(label="Преимущества", lines=4, value="", interactive=True)
            key_message = gr.Textbox(label="Ключевое сообщение", lines=1, value="")
            check_source_btn = gr.Button("Проверить исходные данные")
            source_check_md = gr.Textbox(label="Результат проверки исходных данных", lines=3, 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
                )
            
                source_fields_report = check_source_fields(new_desc, new_pname, new_ben, new_kmsg)
            
                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,
            source_check_md
        ]
    )

    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
        )
    
        source_fields_report = check_source_fields(description, product_name, benefits, key_message)
    
        return chosen_approach_val, p1, p2, "", "", "", "", "", "", source_fields_report

    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]
    )

    check_source_btn.click(
        fn=on_check_source_fields,
        inputs=[description, product_name, benefits, key_message],
        outputs=[source_check_md]
    )

    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()