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
import math
import langchain_gigachat
import logging
from langchain.schema import SystemMessage
import pprint

from langchain_gigachat.chat_models import GigaChat

XAI_API_KEY = os.getenv("XAI_API_KEY")
client = OpenAI(
    api_key=XAI_API_KEY,
    base_url="https://api.x.ai/v1",
)

# Авторизация в GigaChat Pro
gc_key = os.getenv('GC_KEY')
chat_pro = GigaChat(credentials=gc_key, model='GigaChat-Max', max_tokens=68, temperature=0.87, verify_ssl_certs=False, scope="GIGACHAT_API_CORP")

# Функция для генерации сообщения с GigaChat Pro
def call_model(prompt):
    try:
        messages = [SystemMessage(content=prompt)]
        res = chat_pro.invoke(messages)
        print(res.content)
        return res.content
    except Exception as e:
        return f"Ошибка при обращении к GigaChat-Pro: {e}"

token = os.getenv('GITHUB_TOKEN')
repo = "fruitpicker01/Storage_Anastasia"
current_request_index = -1

ABSTRACT_PHRASES = [
    "отличный выбор",
    "зарабатывай больше",
    "отличная возможность",
    "уникальная возможность",
    "специальная скидка",
    "без лишних формальностей",
    "быстро и удобно в любое время",
    "максимальная экономия",
    "уверенный старт",
    "простое управление",
]

CLICHE_PHRASES = [
    "источник гордости",
    "откройте двери",
    "мир бесконечных возможностей",
    "ваш успех начинается здесь",
    "максимальная выгода",
    "гибкие условия",
    "наша забота",
    "что может быть проще",
    "заслуживает лучшего",
    "на полную мощность",
    "не упустите свой шанс на развитие",
    "не упусти возможность",
    "не упусти свой шанс",
    "спеши",
]

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, None
    
    row = df[df[col] == param_value]
    if row.empty:
        return None, None
    
    str_instr1 = row.iloc[0].get("Инструкция 1", "")
    str_instr2 = row.iloc[0].get("Инструкция 2", "")
    
    if not str_instr1.strip():
        str_instr1 = None
    if not str_instr2.strip():
        str_instr2 = None
    
    return str_instr1, str_instr2

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, "ОПФ")
    ]
    
    instructions_1_list = []
    instructions_2_list = []
    
    for (param_value, df, col) in instructions_data:
        i1, i2 = get_instructions_for_param(param_value, df, col)
        # i1, i2 — это то, что вернёт ваша новая функция
        
        if i1:  # если что-то вернулось из «Инструкция 1»
            instructions_1_list.append(i1)
        if i2:  # если что-то вернулось из «Инструкция 2»
            instructions_2_list.append(i2)
    if not instructions_1_list:
        return ("Для формирования промпта выберите хотя бы один личный персональный параметр для определения подхода",
                "Для формирования промпта выберите хотя бы один личный персональный параметр для определения подхода")
        
    lines_1 = []
    for i, instr_line in enumerate(instructions_1_list, start=1):
        # какой-то формат
        lines_1.append(f"{i}. {format_instruction_string(instr_line)}.")
    mandatory_terms_1 = "\n".join(lines_1)
    
    lines_2 = []
    for j, instr_line in enumerate(instructions_2_list, start=1):
        lines_2.append(f"{j}. {format_instruction_string(instr_line)}.")
    mandatory_terms_2 = "\n".join(lines_2)

    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_1}
Убедись, что написал не меньше трех и не больше четырех предложений суммарной длиной от 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:
{mandatory_terms_2}
Убедись, что написал не меньше трех и не больше четырех предложений суммарной длиной от 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)
    text = re.sub(r'(\*|_|`)+', '', 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)
    text = re.sub(r'Qr', 'QR', 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]  # «зарплатным»
        others = []
        for i in range(len(product_words_original[1:])):  # product_name без первого слова
            # Если второе слово в продукте = «Карта», то вставляем ровно его
            if product_words_original[i+1] == "Карта":
                # Берём слово из оригинальной фразы
                others.append(words[i+1])
            else:
                # Смотрим, с какой буквы начинается?
                # Если первая буква строчная, берём исходное (words[i+1])
                # Иначе берём из product_words_original
                if words[i+1] and words[i+1][0].islower():
                    others.append(words[i+1])  # Использовать форму, которую придумала модель
                else:
                    others.append(product_words_original[i+1])

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

        # Собираем обратно измененную часть
        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(model_prompt, product_name):
    last_message = ""
    msg = call_model(model_prompt)
    msg = correct_dash_usage(msg)
    msg = clean_message(msg)
    msg = process_message(msg, product_name)
    length = len(msg)
    last_message = msg
    length = len(msg)
    msg += f"\n\n------\nКоличество знаков: {length}"
    return msg

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()
        
        # Фильтруем только user_request_*.json
        json_files = [f for f in files if f['name'].startswith("user_request_") and f['name'].endswith(".json")]
        if not json_files:
            return (products[0], "", "", "", "", "", None, None, None, None, None, "", "", "", "", "", "")

        # Сортируем по числу после user_request_
        # Разделяем на части user_request_XXXX.json -> берем XXXX как int
        # Затем сортируем по этому числу
        def extract_timestamp(name):
            # name выглядит как "user_request_1735391048.json"
            base = name.split('.')[0]           # "user_request_1735391048"
            part = base.split('_', maxsplit=1) # ["user_request", "1735391048"]
            if len(part) == 2 and part[1].isdigit():
                return int(part[1])
            return 0  # fallback, если что-то не так
        json_files.sort(key=lambda f: extract_timestamp(f['name']), reverse=True)
        
        # Теперь самый новый (с максимальным числом) — json_files[0]
        # «Предыдущий» в списке — json_files[1], и так далее.
        
        # Уменьшаем current_request_index
        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_sms_with_timer(final_prompt_1, product_name, key_message)

    # Выполняем проверки sms_1
    cut_sms_1 = cut_message(sms_1)

    print("[DEBUG B] final check for SMS_1")
    print("[DEBUG B] text going into perform_checks:", repr(cut_sms_1))
    print("[DEBUG B] key_message:", repr(key_message))
    print("[DEBUG B] exceptions_dict:", exceptions_dict)
    print("[DEBUG B] exceptions_dict word_repetitions:", exceptions_dict.get("word_repetitions", None))
    
    checks_1 = perform_checks(cut_sms_1, key_message, exceptions_dict)

    print("[DEBUG B] checks_1 =", checks_1)
    
    checks_formatted_1 = format_checks(checks_1)

    print("[DEBUG B] final checks_1 =>", checks_1)
    print("[DEBUG B] final checks_formatted_1 =>", checks_formatted_1)

    yield(sms_1, "", final_prompt_1, "", checks_formatted_1, "")

    sms_2 = generate_sms_with_timer(final_prompt_2, product_name, key_message)

    # Выполняем проверки sms_2
    cut_sms_2 = cut_message(sms_2)

    print("[DEBUG B] final check for SMS_2")
    print("[DEBUG B] text going into perform_checks:", repr(cut_sms_2))
    print("[DEBUG B] key_message:", repr(key_message))
    print("[DEBUG B] exceptions_dict:", exceptions_dict)
    print("[DEBUG B] exceptions_dict word_repetitions:", exceptions_dict.get("word_repetitions", None))

    pprint.pprint(exceptions_dict, width=120)

    checks_2 = perform_checks(cut_sms_2, key_message, exceptions_dict)

    print("[DEBUG B] checks_2 =", checks_2)
    
    checks_formatted_2 = format_checks(checks_2)

    print("[DEBUG B] final checks_2 =>", checks_2)
    print("[DEBUG B] final checks_formatted_2 =>", checks_formatted_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)
    yield(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 для обновления интерфейса.
    """
    _, exceptions_dict = check_source_fields(description, product_name, benefits, key_message)

    # Перегенерируем 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_sms_with_timer(final_prompt_1, product_name, key_message)

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

    print("[DEBUG on_regenerate] text for sms_1 final check:", repr(cut_sms_1))
    print("[DEBUG on_regenerate] key_message:", repr(key_message))
    print("[DEBUG on_regenerate] exceptions_dict word_repetitions:", exceptions_dict.get("word_repetitions", None))
    print("[DEBUG on_regenerate] checks_1 =", checks_1)
    
    checks_formatted_1 = format_checks(checks_1)

    yield sms_1, "", checks_formatted_1, ""
    
    sms_2 = generate_sms_with_timer(final_prompt_2, product_name, key_message)

    cut_sms_2 = cut_message(sms_2)
    checks_2 = perform_checks(cut_sms_2, key_message, exceptions_dict)

    print("[DEBUG on_regenerate] text for sms_2 final check:", repr(cut_sms_2))
    print("[DEBUG on_regenerate] key_message:", repr(key_message))
    print("[DEBUG on_regenerate] exceptions_dict word_repetitions:", exceptions_dict.get("word_repetitions", None))
    print("[DEBUG on_regenerate] checks_2 =", checks_2)
    
    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 не выбрано
    )

    print("[DEBUG B2] final checks_1 =>", checks_1)
    print("[DEBUG B2] final checks_2 =>", checks_2)

    yield 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, "")
    # Удаляем length_check
    desc_checks.pop("length_check", None)
    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, "")
    name_checks.pop("length_check", None)
    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, "")
    ben_checks.pop("length_check", None)
    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, "")
    km_checks.pop("length_check", None)
    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 == "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)
                        print(f"[DEBUG] Adding word repetition exception: rep_w={rep_w}, lemma={l}")
                        exceptions_dict.setdefault("word_repetitions", set()).add(l)

                elif rule_key == "abstract_phrases":
                    # reason например: "Найдена абстрактная фраза: «отличный выбор»"
                    match = re.search(r'абстрактная фраза:\s*«([^»]+)»', reason, re.IGNORECASE)
                    if match:
                        found_phrase = match.group(1).lower()
                        exceptions_dict.setdefault("abstract_phrases", set()).add(found_phrase)
                
                elif rule_key == "cliche":
                    # reason например: "Найдено клише: «на полную мощность»"
                    match = re.search(r'Найдено клише:\s*«([^»]+)»', reason, re.IGNORECASE)
                    if match:
                        found_phrase = match.group(1).lower()
                        exceptions_dict.setdefault("cliche", set()).add(found_phrase)


        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": "Даты прописью",
        "word_repetitions": "Повторы слов",
        "abstract_phrases": "Абстракции",
        "cliche": "Клише"
    }
    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

# 0. Проверка на длину

def check_length(message):
    length = len(message)
    if 160 <= length <= 250:
        return True
    else:
        logging.warning(f"Не пройдена проверка: Длина сообщения {length} символов. Сообщение: {message}")
        return False

# 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'], считаем нарушением.
    """
    import re
    import pymorphy3

    if exceptions is None:
        exceptions = {}
    allowed_chains = exceptions.get("multiple_nouns", set())

    morph = pymorphy3.MorphAnalyzer()

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

    for sentence in sentences:
        sentence = sentence.strip()
        if not sentence:
            continue

        # 2) Внутри одного предложения извлекаем либо слово (\w+), либо "пунктуацию" ([^\w\s]+)
        #    \w+ = буквенно-цифровая последовательность
        #    [^\w\s]+ = "не-слово", "не-пробел" => любой набор знаков пунктуации
        tokens = re.findall(r'\w+|[^\w\s]+', sentence)

        chain = []
        count = 0

        for token in tokens:
            # 3) Если это набор пунктуации, сбрасываем цепочку
            if re.match(r'[^\w\s]+', token):
                count = 0
                chain.clear()
                continue

            # Иначе это слово => проверяем, NOUN ли это
            p = morph.parse(token)[0]
            if 'NOUN' in p.tag:
                count += 1
                chain.append(p.normal_form)
            else:
                count = 0
                chain.clear()

            # 4) Если встретили 3+ подряд
            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'
    ]

    # Собираем «разрешённые» фразы (из исключений) – это сырые строки:
    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_abstract_phrases(message, exceptions=None):
    """
    Критическая проверка на «абстрактные фразы» (ABSTRACT_PHRASES).
    Если хоть одна из них найдена в тексте (регистронезависимо),
    возвращаем (False, причина).
    """
    if not exceptions:
        exceptions = {}
    allowed_phrases = exceptions.get("abstract_phrases", set())

    for phrase in ABSTRACT_PHRASES:
        # если этой фразы нет в исключениях
        if phrase.lower() not in allowed_phrases:
            # проверяем, содержится ли она в сообщении
            if phrase.lower() in message.lower():
                return (False, f"Найдена абстрактная фраза: «{phrase}»")

    return True  # если ничего не нашли

# Проверка на клише
def check_cliche(message, exceptions=None):
    """
    Некритическая проверка на «клише» (CLICHE_PHRASES).
    Аналогично, если находим — (False, причина).
    """
    if not exceptions:
        exceptions = {}
    allowed_phrases = exceptions.get("cliche", set())

    for phrase in CLICHE_PHRASES:
        if phrase.lower() not in allowed_phrases:
            if phrase.lower() in message.lower():
                return (False, f"Найдено клише: «{phrase}»")

    return True


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

def check_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

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

CRITICAL_CHECKS = [
    "length_check",
    "forbidden_words",
    "client_addressing",
    "promises",
    "subordinate_clauses_chain",
    "introductory_phrases",
    "dates_written_out",
    "abstract_phrases"
]

NON_CRITICAL_CHECKS = [
    "double_verbs",
    "participles",
    "adverbial_participles",
    "superlative_adjectives",
    "passive_voice",
    "written_out_ordinals",
    "repeating_conjunctions",
    "amplifiers",
    "time_parasites",
    "multiple_nouns",
    "derived_prepositions",
    "compound_sentences",
    "word_repetitions",
    "cliche"
]

def run_checks_critical_and_non_critical(message: str, key_message: str) -> (bool, list):
    """
    Возвращает (all_critical_passed: bool, failed_non_critical: list[str])
    где failed_non_critical = список названий проверок, которые не пройдены, но не являются критическими.
    """
    checks = perform_checks(message, key_message)  # ваша функция, которая возвращает dict

    all_critical_passed = True
    failed_non_critical = []

    for rule_name, result in checks.items():
        # result либо True/False, либо (False, reason)
        if isinstance(result, tuple):
            pass_flag = result[0]
        else:
            pass_flag = bool(result)

        if rule_name in CRITICAL_CHECKS:
            if not pass_flag:  # Критическая не пройдена
                all_critical_passed = False
        elif rule_name in NON_CRITICAL_CHECKS:
            if not pass_flag:
                failed_non_critical.append(rule_name)
        else:
            # Все проверки, которых нет ни в CRITICAL_CHECKS, ни в NON_CRITICAL_CHECKS — игнорируем
            pass

    return all_critical_passed, failed_non_critical


def attempt_generate_sms_with_checks(model_prompt: str, product_name: str, key_message: str):
    """
    Генерирует 1 SMS + запускает run_checks_critical_and_non_critical.
    Возвращает (sms, all_critical_ok, failed_non_critical_list).
    """
    sms = generate_message(model_prompt, product_name)
    cut_sms = cut_message(sms)

    print("[DEBUG CYCLE] about to run checks on iteration / generation")
    print("[DEBUG CYCLE] text to check:", repr(cut_sms))
    print("[DEBUG CYCLE] key_message:", repr(key_message))

    all_critical_ok, failed_non_crit = run_checks_critical_and_non_critical(cut_sms, key_message)
    
    print("[DEBUG A] attempt_generate_sms_with_checks => sms full:", repr(sms))
    print("[DEBUG A] attempt_generate_sms_with_checks => sms cut:", repr(cut_sms))
    print("[DEBUG A] attempt_generate_sms_with_checks => key_message:", repr(key_message))
    print("[DEBUG A] => all_critical_ok=", all_critical_ok, "failed_non_crit=", failed_non_crit)

    return sms, all_critical_ok, failed_non_crit


def generate_sms_with_timer(model_prompt: str, product_name: str, key_message: str, max_time_sec=90):
    """
    Псевдо-синхронный цикл с таймером 90 секунд.
    Возвращает "оптимальный" SMS, 
    или строку "Не удалось за 1,5 минуты создать SMS, прошедшее все критические проверки".
    """
    start = time.time()
    best_sms = None
    best_non_crit_count = math.inf  # сколько некритич. проверок не пройдено (минимизируем)

    i = 0  # Счётчик итераций
    while True:
        i += 1
        now = time.time()
        elapsed = now - start

        # Печатаем отладку по каждой итерации
        print(f"[DEBUG] iteration={i}, elapsed={elapsed:.1f} s")

        # Проверяем, не вышли ли за предел 90 секунд
        if elapsed > max_time_sec:
            print(f"[DEBUG] таймер вышел: elapsed={elapsed:.1f} s => break")
            break

        # Генерируем SMS и проверяем
        sms, crit_ok, failed_non_crit = attempt_generate_sms_with_checks(model_prompt, product_name, key_message)
        print(f"[DEBUG] iteration={i}, crit_ok={crit_ok}, failed_non_crit={failed_non_crit}")

        if crit_ok:
            # SMS прошло критические проверки
            non_crit_count = len(failed_non_crit)
            if non_crit_count == 0:
                # Идеальное SMS => сразу return
                print(f"[DEBUG] iteration={i} => нашли SMS без некритических ошибок, возвращаем сразу.")
                return sms

            if non_crit_count < best_non_crit_count:
                best_non_crit_count = non_crit_count
                best_sms = sms
                print(f"[DEBUG] iteration={i} => новое лучшее SMS, некритических={best_non_crit_count}")

        # Если crit_fail, идём на следующую итерацию, без обновлений best_sms

        # (опционально) time.sleep(1) — чтобы не «спамить» модель слишком часто
    
    # Если дошли сюда, значит время вышло (или цикл прерван вручную где-то)
    if best_sms is not None:
        print(f"[DEBUG] время истекло, возвращаем best_sms c {best_non_crit_count} некрит. ошибками")
        return best_sms
    else:
        print("[DEBUG] ни одно SMS не прошло критические проверки => возвращаем фейл")
        return "Не удалось за 1,5 минуты создать SMS, прошедшее все критические проверки."


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 = {
        "length_check": safe_check(check_length, message),
        "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),
        "word_repetitions": safe_check(lambda msg, km: check_word_repetitions(msg, km, exceptions_dict), message, key_message),
        "abstract_phrases": safe_check(lambda msg: check_abstract_phrases(msg, exceptions_dict), message),
        "cliche": safe_check(lambda msg: check_cliche(msg, exceptions_dict), message)
    }

    print(f"[DEBUG perform_checks] message={repr(message)} key_message={repr(key_message)}\n"
          f"  => checks={checks}\n"
          f"  => exceptions_dict={exceptions_dict}")

    return checks
    
def format_checks(checks):
    
    translation = {
        "length_check": "Длина",
        "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": "Даты прописью",
        "word_repetitions": "Повторы слов",
        "abstract_phrases": "Абстракции",
        "cliche": "Клише"
    }

    critical_lines = []
    non_critical_lines = []

    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 = "❓"
        
        # Формируем строку вида "Имя проверки: ✔️/❌"
        line = f"{rule_name}: {symbol}"

        # Раскладываем по группам
        if rule in CRITICAL_CHECKS:
            critical_lines.append(line)
        else:
            non_critical_lines.append(line)

    text_parts = []

    if critical_lines:
        text_parts.append("**Критические проверки**:")
        text_parts.extend(critical_lines)
    if non_critical_lines:
        text_parts.append("")
        text_parts.append("**Некритические проверки**:")
        text_parts.extend(non_critical_lines)

    # Склеиваем в одну многострочную строку
    result_text = "  \n".join(text_parts)
    return result_text

    

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)

    gr.Markdown("---")

    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="GigaChat", 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="GigaChat", 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=on_check_source_fields,
        inputs=[description, product_name, benefits, key_message],
        outputs=[source_check_md]
    )

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

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