python
import os
import pandas as pd
from collections import deque
from sympy import symbols, Eq, solve
from datetime import datetime, timedelta

# Словарь со значениями пороговых коэффициентов для каждой лиги
league_thresholds = {
    "Albania Superiore": (2.52, 2.73),
    "Andorra Primera": (2.42, 2.75),
    "Armenia Premier": (2.32, 3.20),
    "Bosnia WWin Liga": (2.00, 3.20),
    "Croatia HNL": (2.29, 3.25),
    "Cyprus League": (2.25, 3.20),
    "Cyprus Division 2": (2.46, 2.70),
    "Czech Chance Liga": (2.25, 3.30),
    "Denmark Superliga": (2.40, 3.00),
    "Greece Super League": (2.36, 3.40),
    "Greece Super League 2": (2.25, 3.30),
    "Hungary OTP Bank Liga": (2.17, 3.40),
    "Hungary Merkantil Bank Liga": (2.38, 3.30),
    "Luxembourg BGL Ligue": (2.20, 3.00),
    "Malta Premier League": (2.75, 2.60),   # Обратите внимание, что здесь home > away
    "Montenegro Prva Liga": (2.50, 3.20),
    "North Macedonia 1 MFL": (2.13, 3.60),
    "Slovakia Nike Liga": (2.30, 3.00),
    "Slovenia Prva Liga": (2.47, 3.00),
    "Algeria Ligue 2": (1.87, 5.00),
    "Mexico Liga de Expansion MX": (2.00, 4.00),
    "South Africa Premiership": (2.31, 3.45),
    "Croatia Prva NL": (2.40, 2.80),
    "India ISL": (2.17, 3.33),
    "Indonesia Liga 1": (2.27, 3.45),
    "Bulgaria Vtora liga": (2.27, 3.45),
    "Zambia Super League": (2.47, 3.10),
    "Romania Liga 3": (2.30, 2.94),
    "Myanmar National League": (2.50, 2.50),
    "Tanzania Ligi Kuu Bara": (2.20, 3.30),
    "France Nacional": (2.32, 3.30),
    "Nigeria NPFL": (1.50, 6.00),
    "Turkey 1.Lig": (2.27, 3.20),
    "Algeria Ligue 1": (2.05, 4.30),
    "Italy Serie C - A": (2.38, 3.30),
    "Italy Serie B": (2.46, 3.50),
    "Algeria Ligue 2 - 21": (2.00, 3.20),
    "England National League South": (2.38, 3.00),
    "Brazil Paulista A4": (2.44, 3.00),
    "Ethiopia": (3.12, 2.85),
    "Spain LaLiga": (2.29, 3.61),
    "Australia NPL": (2.22, 3.00),
    "Bulgaria Vtora Liga": (2.08, 3.70),
    "Italy Serie C - C": (2.40, 3.20),
    "Spain Segunda": (2.11, 4.02),
    "France Ligue 1": (2.30, 3.60),
    "Brazil Serie A": (2.05, 4.00),
    "Brazil Serie B": (2.05, 4.00),
    "Brazil Serie C": (2.15, 3.70),
    "Iceland Besta Delid": (2.12, 3.10),
    "Australia NPL Northern": (2.47, 2.30),
    "Norway Division 2": (2.08, 2.94),
    "USA MLS": (2.27, 3.20),
    "Argentina": (2.22, 3.80),
    "Mexico": (2.08, 3.80),
    "Bundesliga - 2": (2.16, 3.55),
    "France - 2": (2.16, 3.55),
    "Netherlands - Eridivisie": (2.20, 3.20),
    "England - Premier League": (2.18, 3.60)
}

# Функция для очистки имен команд от лишних пробелов
def clean_team_name(name):
    if isinstance(name, str):
        return ' '.join(name.strip().split())
    return name

# Чтение данных из Excel файла
excel_file_path = r"C:\Users\User\Desktop\results\results.xlsx"
df = pd.read_excel(excel_file_path)

# Преобразуем каждую строку в кортеж с учётом лиги (колонка A)
matches = []
for _, row in df.iterrows():
    match = (
        row[0],  # Лига (колонка A)
        row[1],  # Дата (колонка B)
        clean_team_name(row[2]),  # Домашняя команда (колонка C)
        clean_team_name(row[3]),  # Гостевая команда (колонка D)
        row[4],  # Коэффициент 1 (колонка E)
        row[5],  # Коэффициент на ничью (колонка F)
        row[6]   # Коэффициент 2 (колонка G)
    )
    matches.append(match)

# Функция для поиска всех цепочек между двумя командами
def find_chains(matches, start_team, end_team, min_depth=1, max_depth=4):
    # Создание графа игр (по принципу «команда – список (сосед, матч)»)
    graph = {}
    for match in matches:
        league, date, home_team, away_team, odds1, odds_draw, odds2 = match

        if home_team not in graph:
            graph[home_team] = []
        if away_team not in graph:
            graph[away_team] = []

        # Включаем в граф связь home_team -> (away_team, match) и наоборот
        graph[home_team].append((away_team, match))
        graph[away_team].append((home_team, match))

    # Поиск в ширину для нахождения всех цепочек
    from collections import deque
    chains = []
    queue = deque([(start_team, [], set())])

    while queue:
        current_team, path, visited = queue.popleft()
        if current_team == end_team and path:
            if min_depth <= len(path) <= max_depth:
                chains.append(path)
            continue

        if len(path) >= max_depth:
            continue

        for neighbor, match in graph.get(current_team, []):
            if match not in visited:
                new_visited = visited.copy()
                new_visited.add(match)
                queue.append((neighbor, path + [match], new_visited))

    return chains

# ===== ДОБАВЛЕНО: ввод списка пар или режим 2 команд =====
raw_input_teams = input("Введите название стартовой команды: ").strip()

team_pairs = []

# Если введён список пар (через запятую) или одна пара формата "TeamA - TeamB"
if (',' in raw_input_teams) or (' - ' in raw_input_teams):
    parts = [p.strip() for p in raw_input_teams.split(',') if p.strip()]

    for p in parts:
        if ' - ' not in p:
            print(f"Пропуск (неверный формат, нужен 'Команда1 - Команда2'): {p}")
            continue
        a, b = p.split(' - ', 1)
        a = clean_team_name(a)
        b = clean_team_name(b)
        if a and b:
            team_pairs.append((a, b))

    if not team_pairs:
        # Если ничего корректно не распарсили, падаем обратно в режим 2 команд
        start_team = clean_team_name(raw_input_teams)
        end_team   = clean_team_name(input("Введите название команды назначения: ").strip())
        team_pairs = [(start_team, end_team)]
else:
    # Обычный режим: 2 команды
    start_team = clean_team_name(raw_input_teams)
    end_team   = clean_team_name(input("Введите название команды назначения: ").strip())
    team_pairs = [(start_team, end_team)]
# ===== КОНЕЦ ДОБАВЛЕНИЯ =====

# Класс для расчета силы команд
class TeamStrengthCalculator:
    def __init__(self):
        self.games = []
        self.equations_method_1 = []
        self.equations_method_2 = []
        self.teams = set()

    def add_games(self, games):
        """
        games – список кортежей: (league, date, home_team, away_team, odds1, odds_draw, odds2)
        """
        for g in games:
            league, date, home_team, away_team, home_odds, draw_odds, away_odds = g
            self.games.append({
                'league': league,
                'date': date,
                'home_team': clean_team_name(home_team),
                'away_team': clean_team_name(away_team),
                'home_odds': float(str(home_odds).replace(',', '.')),
                'draw_odds': float(str(draw_odds).replace(',', '.')),
                'away_odds': float(str(away_odds).replace(',', '.'))
            })
            self.teams.add(clean_team_name(home_team))
            self.teams.add(clean_team_name(away_team))

    def calculate_strength_difference_method_1(self):
        """
        Метод 1. Для каждого матча берём индивидуальные пороги (threshold_home, threshold_away)
        и формируем «уравнения» (строки), которые потом решаются в simplify_with_sympy.
        """
        for game in self.games:
            league_name = game['league']
            home_team   = game['home_team']
            away_team   = game['away_team']
            home_odds   = game['home_odds']
            away_odds   = game['away_odds']

            # Берём пороги для данной лиги (или по умолчанию 2.40 и 3.00)
            threshold_home, threshold_away = league_thresholds.get(league_name, (2.40, 3.00))

            if home_odds < threshold_home and away_odds > threshold_away:
                # формируем "уравнение": "HomeTeam = AwayTeam + 0.123"
                home_strength = (100 / threshold_home) - (100 / home_odds)
                away_strength = (100 / away_odds) - (100 / threshold_away)
                strength_difference = (abs(home_strength) + abs(away_strength)) / 2
                self.equations_method_1.append(
                    f"{home_team} = {away_team} + {strength_difference:.3f}"
                )

            elif home_odds > threshold_home and away_odds < threshold_away:
                home_strength = (100 / home_odds) - (100 / threshold_home)
                away_strength = (100 / threshold_away) - (100 / away_odds)
                strength_difference = (abs(home_strength) + abs(away_strength)) / 2
                self.equations_method_1.append(
                    f"{away_team} = {home_team} + {strength_difference:.3f}"
                )
            else:
                # Игнорируем для метода 1, если не подошли под условия
                pass

    def calculate_strength_difference_method_2(self):
        """
        Метод 2. Аналогично, но с другой логикой.
        """
        for game in self.games:
            league_name = game['league']
            home_team   = game['home_team']
            away_team   = game['away_team']
            home_odds   = game['home_odds']
            away_odds   = game['away_odds']

            threshold_home, threshold_away = league_thresholds.get(league_name, (2.40, 3.00))

            if home_odds < away_odds:
                # хозяева считаются фаворитом
                if home_odds < threshold_home:
                    home_strength = abs((100 / threshold_home) - (100 / home_odds))
                    self.equations_method_2.append(
                        f"{home_team} = {away_team} + {home_strength:.3f}"
                    )
                else:
                    home_strength = abs((100 / home_odds) - (100 / threshold_home))
                    self.equations_method_2.append(
                        f"{away_team} = {home_team} + {home_strength:.3f}"
                    )
            else:
                # гости считаются фаворитом
                if away_odds < threshold_away:
                    away_strength = abs((100 / threshold_away) - (100 / away_odds))
                    self.equations_method_2.append(
                        f"{away_team} = {home_team} + {away_strength:.3f}"
                    )
                else:
                    away_strength = abs((100 / away_odds) - (100 / threshold_away))
                    self.equations_method_2.append(
                        f"{home_team} = {away_team} + {away_strength:.3f}"
                    )

    def simplify_with_sympy(self, start_team, end_team):
        """
        Решаем сформированные «уравнения» и вычисляем разницу сил между start_team и end_team.
        В этом методе также берём пороги исходя из лиги первого матча в self.games
        (если в цепочке несколько лиг – используем первую).
        """
        if not self.games:
            print("Нет матчей для расчета.")
            return []

        # Лига первого матча (если цепочка состоит из нескольких лиг, берём первую)
        first_league = self.games[0]['league']
        threshold_home, threshold_away = league_thresholds.get(first_league, (2.40, 3.00))

        # Создаём символы для каждой команды
        team_symbols = {}
        for team in self.teams:
            if team == start_team:
                # Фиксируем силу стартовой команды = 0
                team_symbols[team] = 0
            else:
                safe_name = team.replace(' ', '_').replace('-', '_')
                team_symbols[team] = symbols(safe_name)

        # Преобразуем equations_method_1 в список уравнений SymPy
        sympy_equations_method_1 = []
        for equation in self.equations_method_1:
            parts = equation.split('=')
            if len(parts) == 2 and '+' in parts[1]:
                left_team, right = parts[0].strip(), parts[1].strip()
                right_team, strength_diff = right.split('+')
                right_team = right_team.strip()
                strength_diff = float(strength_diff.strip())
                left_sym = team_symbols[left_team]
                right_sym = team_symbols[right_team]
                sympy_equations_method_1.append(Eq(left_sym, right_sym + strength_diff))

        # Преобразуем equations_method_2 в список уравнений SymPy
        sympy_equations_method_2 = []
        for equation in self.equations_method_2:
            parts = equation.split('=')
            if len(parts) == 2 and '+' in parts[1]:
                left_team, right = parts[0].strip(), parts[1].strip()
                right_team, strength_diff = right.split('+')
                right_team = right_team.strip()
                strength_diff = float(strength_diff.strip())
                left_sym = team_symbols[left_team]
                right_sym = team_symbols[right_team]
                sympy_equations_method_2.append(Eq(left_sym, right_sym + strength_diff))

        # Формируем список символов (исключая те, что зафиксированы = 0)
        symbols_list = [sym for sym in team_symbols.values() if sym != 0]

        # Решение уравнений
        solution_1 = solve(sympy_equations_method_1, symbols_list, dict=True) if sympy_equations_method_1 else []
        solution_2 = solve(sympy_equations_method_2, symbols_list, dict=True) if sympy_equations_method_2 else []

        # Ищем символ для end_team
        end_symbol = team_symbols.get(end_team)
        final_results = []

        # --- Обработка результатов метода 1 ---
        if solution_1 and end_symbol is not None:
            sol = solution_1[0]
            if end_symbol in sol:
                end_value = sol[end_symbol]
                try:
                    end_value_numeric = float(end_value.evalf())
                    # сила start_team = 0, значит разница (start_team - end_team) = -end_value_numeric
                    strength_diff = -end_value_numeric
                    new_odds_start = 100 / ((100 / threshold_home) + strength_diff)
                    new_odds_end   = 100 / ((100 / threshold_home) - strength_diff)
                    final_results.append(
                        f"Method 1: {start_team} = {end_team} + {strength_diff:.3f}; "
                        f"{start_team} odds = {new_odds_start:.3f}; {end_team} odds = {new_odds_end:.3f}"
                    )
                except (TypeError, ValueError):
                    print(f"Не удалось вычислить численное значение силы {end_team} в методе 1.")
            else:
                print(f"Команда {end_team} не найдена в решении метода 1.")
        else:
            print("Нет решения для метода 1.")

        # --- Обработка результатов метода 2 ---
        if solution_2 and end_symbol is not None:
            sol = solution_2[0]
            if end_symbol in sol:
                end_value = sol[end_symbol]
                try:
                    end_value_numeric = float(end_value.evalf())
                    strength_diff = -end_value_numeric
                    new_odds_start = 100 / ((100 / threshold_home) + strength_diff)
                    new_odds_end   = 100 / ((100 / threshold_home) - strength_diff)
                    final_results.append(
                        f"Method 2: {start_team} = {end_team} + {strength_diff:.3f}; "
                        f"{start_team} odds = {new_odds_start:.3f}; {end_team} odds = {new_odds_end:.3f}"
                    )
                except (TypeError, ValueError):
                    print(f"Не удалось вычислить численное значение силы {end_team} в методе 2.")
            else:
                print(f"Команда {end_team} не найдена в решении метода 2.")
        else:
            print("Нет решения для метода 2.")

        # Вывод итоговых результатов
        if final_results:
            for result in final_results:
                print(result)
        else:
            print("Не удалось вычислить разницу в силе между командами.")

        # ===== ДОБАВЛЕНО: возвращаем результаты для сохранения в Excel =====
        return final_results
        # ===== КОНЕЦ ДОБАВЛЕНИЯ =====

# ===== ДОБАВЛЕНО: накопление результатов для сохранения в Excel =====
all_results_rows = []
# ===== КОНЕЦ ДОБАВЛЕНИЯ =====

# ===== ДОБАВЛЕНО: обработка сразу нескольких пар (или одной) =====
for request_num, (start_team, end_team) in enumerate(team_pairs, start=1):

    # Поиск цепочек между двумя заданными командами
    chains = find_chains(matches, start_team, end_team)

    # Удаляем дубликаты цепочек
    unique_chains = []
    seen_chains = set()

    for chain in chains:
        chain_tuple = tuple(chain)
        if chain_tuple not in seen_chains:
            seen_chains.add(chain_tuple)
            unique_chains.append(chain)

    chains = unique_chains

    # Если цепочки найдены
    if chains:
        # Группируем цепочки по длине
        chain_groups = {}
        for chain in chains:
            chain_length = len(chain)
            if chain_length not in chain_groups:
                chain_groups[chain_length] = []

            # Вычисляем «среднюю дату» в цепочке (для сортировки от более новых к старым)
            dates = []
            for match in chain:
                # match[1] – это дата
                raw_date = match[1]
                date_obj = None

                # Пытаемся аккуратно преобразовать к datetime
                if isinstance(raw_date, datetime):
                    date_obj = raw_date
                elif isinstance(raw_date, (float, int)):
                    # Считаем, что это Excel-формат дат (кол-во дней с 30.12.1899).
                    try:
                        date_obj = datetime(1899, 12, 30) + timedelta(days=int(raw_date))
                    except:
                        date_obj = None
                elif isinstance(raw_date, str):
                    # Проверяем, есть ли разделитель " - "
                    try:
                        if ' - ' in raw_date:
                            date_part = raw_date.split(' - ')[0].strip()  # "dd.mm.yyyy"
                            date_obj = datetime.strptime(date_part, '%d.%m.%Y')
                        else:
                            # Может быть просто "dd.mm.yyyy"
                            date_obj = datetime.strptime(raw_date.strip(), '%d.%m.%Y')
                    except:
                        date_obj = None

                if date_obj:
                    dates.append(date_obj)
                else:
                    print(f"Не удалось интерпретировать дату: {raw_date}")

            if dates:
                avg_timestamp = sum(d.timestamp() for d in dates) / len(dates)
                avg_date = datetime.fromtimestamp(avg_timestamp)
                chain_groups[chain_length].append({'chain': chain, 'avg_date': avg_date})
            else:
                # Если не получилось распарсить ни одной даты, ставим минимальную для сортировки
                chain_groups[chain_length].append({'chain': chain, 'avg_date': datetime.min})

        # Сортируем цепочки в каждой группе по средней дате (от более свежей к более старой)
        for chain_length in sorted(chain_groups.keys()):
            chain_infos = chain_groups[chain_length]
            chain_infos_sorted = sorted(chain_infos, key=lambda x: x['avg_date'], reverse=True)
            chain_groups[chain_length] = chain_infos_sorted

        # Выводим результаты
        chain_index = 1
        for chain_length in sorted(chain_groups.keys()):
            print(f"\n=== (Запрос {request_num}) {start_team} -> {end_team} | Цепочки из {chain_length} WTP ===\n")
            chain_infos = chain_groups[chain_length]
            for chain_info in chain_infos:
                chain = chain_info['chain']
                avg_date = chain_info['avg_date']
                avg_date_str = avg_date.strftime('%d.%m.%Y') if avg_date != datetime.min else ""

                print(f"Цепочка {chain_index} (Средняя дата: {avg_date_str}):")

                # Собираем матчи и лиги
                games = []
                used_leagues = set()
                match_lines = []

                for match in chain:
                    league, date, home_team, away_team, odds1, odds_draw, odds2 = match
                    # Упрощенный вывод каждого матча
                    print(f"('{date}', '{home_team}', '{away_team}', {odds1}, {odds_draw}, {odds2})")
                    games.append(match)
                    used_leagues.add(league)
                    match_lines.append(f"('{date}', '{home_team}', '{away_team}', {odds1}, {odds_draw}, {odds2})")

                print("\nИспользуемые лиги в цепочке и их пороги:")
                for lg in sorted(used_leagues):
                    th_home, th_away = league_thresholds.get(lg, (2.40, 3.00))
                    print(f"    Лига: {lg} → home={th_home}, away={th_away}")

                # Расчет и вывод методов
                calculator = TeamStrengthCalculator()
                calculator.add_games(games)
                calculator.calculate_strength_difference_method_1()
                calculator.calculate_strength_difference_method_2()
                final_results = calculator.simplify_with_sympy(start_team, end_team)

                # ===== ДОБАВЛЕНО: запись результатов в таблицу для Excel =====
                method1_text = ""
                method2_text = ""
                for r in final_results:
                    if r.startswith("Method 1:"):
                        method1_text = r
                    elif r.startswith("Method 2:"):
                        method2_text = r

                all_results_rows.append({
                    "Request #": request_num,
                    "Start Team": start_team,
                    "End Team": end_team,
                    "Chain #": chain_index,
                    "Chain Length (WTP)": chain_length,
                    "Average Date": avg_date_str,
                    "Matches": "\n".join(match_lines),
                    "Used Leagues": ", ".join(sorted(used_leagues)),
                    "Method 1 Result": method1_text,
                    "Method 2 Result": method2_text
                })
                # ===== КОНЕЦ ДОБАВЛЕНИЯ =====

                print("\n" + "="*75 + "\n")
                chain_index += 1
    else:
        print(f"Не найдены WTP-цепочки между указанными командами: {start_team} -> {end_team}")

        # ===== ДОБАВЛЕНО: фиксируем отсутствие цепочек в Excel-отчёте =====
        all_results_rows.append({
            "Request #": request_num,
            "Start Team": start_team,
            "End Team": end_team,
            "Chain #": "",
            "Chain Length (WTP)": "",
            "Average Date": "",
            "Matches": "",
            "Used Leagues": "",
            "Method 1 Result": "Не найдены WTP-цепочки",
            "Method 2 Result": "Не найдены WTP-цепочки"
        })
        # ===== КОНЕЦ ДОБАВЛЕНИЯ =====
# ===== КОНЕЦ ДОБАВЛЕНИЯ =====

# ===== ДОБАВЛЕНО: сохранение результатов в новый Excel-файл =====
if all_results_rows:
    out_dir = os.path.dirname(excel_file_path) if os.path.dirname(excel_file_path) else os.getcwd()
    out_name = f"wtp_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
    output_excel_path = os.path.join(out_dir, out_name)

    out_df = pd.DataFrame(all_results_rows)
    out_df.to_excel(output_excel_path, index=False)

    print(f"\nГотово. Результаты сохранены в Excel:\n{output_excel_path}")
# ===== КОНЕЦ ДОБАВЛЕНИЯ =====

python
import os
import pandas as pd
from collections import deque
from sympy import symbols, Eq, solve
from datetime import datetime, timedelta

from openpyxl import Workbook, load_workbook
from openpyxl.styles import Alignment

# Словарь со значениями пороговых коэффициентов для каждой лиги
league_thresholds = {
    "Albania Superiore": (2.52, 2.73),
    "Andorra Primera": (2.42, 2.75),
    "Armenia Premier": (2.32, 3.20),
    "Bosnia WWin Liga": (2.00, 3.20),
    "Croatia HNL": (2.29, 3.25),
    "Cyprus League": (2.25, 3.20),
    "Cyprus Division 2": (2.46, 2.70),
    "Czech Chance Liga": (2.25, 3.30),
    "Denmark Superliga": (2.40, 3.00),
    "Greece Super League": (2.36, 3.40),
    "Greece Super League 2": (2.25, 3.30),
    "Hungary OTP Bank Liga": (2.17, 3.40),
    "Hungary Merkantil Bank Liga": (2.38, 3.30),
    "Luxembourg BGL Ligue": (2.20, 3.00),
    "Malta Premier League": (2.75, 2.60),   # Обратите внимание, что здесь home > away
    "Montenegro Prva Liga": (2.50, 3.20),
    "North Macedonia 1 MFL": (2.13, 3.60),
    "Slovakia Nike Liga": (2.30, 3.00),
    "Slovenia Prva Liga": (2.47, 3.00),
    "Algeria Ligue 2": (1.87, 5.00),
    "Mexico Liga de Expansion MX": (2.00, 4.00),
    "South Africa Premiership": (2.31, 3.45),
    "Croatia Prva NL": (2.40, 2.80),
    "India ISL": (2.17, 3.33),
    "Indonesia Liga 1": (2.27, 3.45),
    "Bulgaria Vtora liga": (2.27, 3.45),
    "Zambia Super League": (2.47, 3.10),
    "Romania Liga 3": (2.30, 2.94),
    "Myanmar National League": (2.50, 2.50),
    "Tanzania Ligi Kuu Bara": (2.20, 3.30),
    "France Nacional": (2.32, 3.30),
    "Nigeria NPFL": (1.50, 6.00),
    "Turkey 1.Lig": (2.27, 3.20),
    "Algeria Ligue 1": (2.05, 4.30),
    "Italy Serie C - A": (2.38, 3.30),
    "Italy Serie B": (2.46, 3.50),
    "Algeria Ligue 2 - 21": (2.00, 3.20),
    "England National League South": (2.38, 3.00),
    "Brazil Paulista A4": (2.44, 3.00),
    "Ethiopia": (3.12, 2.85),
    "Spain LaLiga": (2.29, 3.61),
    "Australia NPL": (2.22, 3.00),
    "Bulgaria Vtora Liga": (2.08, 3.70),
    "Italy Serie C - C": (2.40, 3.20),
    "Spain Segunda": (2.11, 4.02),
    "France Ligue 1": (2.30, 3.60),
    "Brazil Serie A": (2.05, 4.00),
    "Brazil Serie B": (2.05, 4.00),
    "Brazil Serie C": (2.15, 3.70),
    "Iceland Besta Delid": (2.12, 3.10),
    "Australia NPL Northern": (2.47, 2.30),
    "Norway Division 2": (2.08, 2.94),
    "USA MLS": (2.27, 3.20),
    "Argentina": (2.22, 3.80),
    "Mexico": (2.08, 3.80),
    "Bundesliga - 2": (2.16, 3.55),
    "France - 2": (2.16, 3.55),
    "Netherlands - Eridivisie": (2.20, 3.20),
    "England - Premier League": (2.18, 3.60)
}

# Функция для очистки имен команд от лишних пробелов
def clean_team_name(name):
    if isinstance(name, str):
        return ' '.join(name.strip().split())
    return name

# Чтение данных из Excel файла
excel_file_path = r"C:\Users\User\Desktop\results\results.xlsx"
df = pd.read_excel(excel_file_path)

# Преобразуем каждую строку в кортеж с учётом лиги (колонка A)
matches = []
for _, row in df.iterrows():
    match = (
        row[0],  # Лига (колонка A)
        row[1],  # Дата (колонка B)
        clean_team_name(row[2]),  # Домашняя команда (колонка C)
        clean_team_name(row[3]),  # Гостевая команда (колонка D)
        row[4],  # Коэффициент 1 (колонка E)
        row[5],  # Коэффициент на ничью (колонка F)
        row[6]   # Коэффициент 2 (колонка G)
    )
    matches.append(match)

# Функция для поиска всех цепочек между двумя командами
def find_chains(matches, start_team, end_team, min_depth=1, max_depth=4):
    # Создание графа игр (по принципу «команда – список (сосед, матч)»)
    graph = {}
    for match in matches:
        league, date, home_team, away_team, odds1, odds_draw, odds2 = match

        if home_team not in graph:
            graph[home_team] = []
        if away_team not in graph:
            graph[away_team] = []

        # Включаем в граф связь home_team -> (away_team, match) и наоборот
        graph[home_team].append((away_team, match))
        graph[away_team].append((home_team, match))

    # Поиск в ширину для нахождения всех цепочек
    from collections import deque
    chains = []
    queue = deque([(start_team, [], set())])

    while queue:
        current_team, path, visited = queue.popleft()
        if current_team == end_team and path:
            if min_depth <= len(path) <= max_depth:
                chains.append(path)
            continue

        if len(path) >= max_depth:
            continue

        for neighbor, match in graph.get(current_team, []):
            if match not in visited:
                new_visited = visited.copy()
                new_visited.add(match)
                queue.append((neighbor, path + [match], new_visited))

    return chains

# ===== ДОБАВЛЕНО: ввод списка пар или режим 2 команд =====
raw_input_teams = input(
    "Введите либо 2 команды (как раньше), либо список пар через запятую.\n"
    "Пример: Malaga - Granada, Granada - Albacete\n"
    "Ввод: "
).strip()

team_pairs = []

# Если введён список пар (через запятую) или одна пара формата "TeamA - TeamB"
if (',' in raw_input_teams) or (' - ' in raw_input_teams):
    parts = [p.strip() for p in raw_input_teams.split(',') if p.strip()]

    for p in parts:
        if ' - ' not in p:
            print(f"Пропуск (неверный формат, нужен 'Команда1 - Команда2'): {p}")
            continue
        a, b = p.split(' - ', 1)
        a = clean_team_name(a)
        b = clean_team_name(b)
        if a and b:
            team_pairs.append((a, b))

    if not team_pairs:
        # Если ничего корректно не распарсили, падаем обратно в режим 2 команд
        start_team = clean_team_name(raw_input_teams)
        end_team   = clean_team_name(input("Введите название команды назначения: ").strip())
        team_pairs = [(start_team, end_team)]
else:
    # Обычный режим: 2 команды
    start_team = clean_team_name(raw_input_teams)
    end_team   = clean_team_name(input("Введите название команды назначения: ").strip())
    team_pairs = [(start_team, end_team)]
# ===== КОНЕЦ ДОБАВЛЕНИЯ =====

# ===== ДОБАВЛЕНО: сохранение в ОДИН Excel и дописывание "как в Word" =====
def append_text_report_to_excel(output_excel_path, text_block):
    """
    Пишем отчёт "как в Word": один большой текст в одной ячейке (A),
    переносы строк внутри, скрытые сетки, ширина колонки большая.
    Каждый новый запуск дописывает ниже (не создаёт новый файл).
    """
    if os.path.exists(output_excel_path):
        wb = load_workbook(output_excel_path)
        if "Report" in wb.sheetnames:
            ws = wb["Report"]
        else:
            ws = wb.create_sheet("Report")
    else:
        wb = Workbook()
        ws = wb.active
        ws.title = "Report"

    # Настройки вида (чтобы было ближе к Word)
    ws.sheet_view.showGridLines = False
    ws.column_dimensions["A"].width = 140

    # Ищем следующую строку для записи (оставляем пустую строку между блоками)
    if ws.max_row == 1 and ws["A1"].value is None:
        next_row = 1
    else:
        next_row = ws.max_row + 2

    cell = ws.cell(row=next_row, column=1, value=text_block)
    cell.alignment = Alignment(wrap_text=True, vertical="top")

    # Примерная высота строки по количеству строк текста (Excel ограничен высотой строки)
    line_count = text_block.count("\n") + 1
    approx_height = 15 * line_count
    ws.row_dimensions[next_row].height = min(max(15, approx_height), 409)

    wb.save(output_excel_path)
# ===== КОНЕЦ ДОБАВЛЕНИЯ =====

# Класс для расчета силы команд
class TeamStrengthCalculator:
    def __init__(self):
        self.games = []
        self.equations_method_1 = []
        self.equations_method_2 = []
        self.teams = set()

    def add_games(self, games):
        """
        games – список кортежей: (league, date, home_team, away_team, odds1, odds_draw, odds2)
        """
        for g in games:
            league, date, home_team, away_team, home_odds, draw_odds, away_odds = g
            self.games.append({
                'league': league,
                'date': date,
                'home_team': clean_team_name(home_team),
                'away_team': clean_team_name(away_team),
                'home_odds': float(str(home_odds).replace(',', '.')),
                'draw_odds': float(str(draw_odds).replace(',', '.')),
                'away_odds': float(str(away_odds).replace(',', '.'))
            })
            self.teams.add(clean_team_name(home_team))
            self.teams.add(clean_team_name(away_team))

    def calculate_strength_difference_method_1(self):
        """
        Метод 1. Для каждого матча берём индивидуальные пороги (threshold_home, threshold_away)
        и формируем «уравнения» (строки), которые потом решаются в simplify_with_sympy.
        """
        for game in self.games:
            league_name = game['league']
            home_team   = game['home_team']
            away_team   = game['away_team']
            home_odds   = game['home_odds']
            away_odds   = game['away_odds']

            # Берём пороги для данной лиги (или по умолчанию 2.40 и 3.00)
            threshold_home, threshold_away = league_thresholds.get(league_name, (2.40, 3.00))

            if home_odds < threshold_home and away_odds > threshold_away:
                home_strength = (100 / threshold_home) - (100 / home_odds)
                away_strength = (100 / away_odds) - (100 / threshold_away)
                strength_difference = (abs(home_strength) + abs(away_strength)) / 2
                self.equations_method_1.append(
                    f"{home_team} = {away_team} + {strength_difference:.3f}"
                )

            elif home_odds > threshold_home and away_odds < threshold_away:
                home_strength = (100 / home_odds) - (100 / threshold_home)
                away_strength = (100 / threshold_away) - (100 / away_odds)
                strength_difference = (abs(home_strength) + abs(away_strength)) / 2
                self.equations_method_1.append(
                    f"{away_team} = {home_team} + {strength_difference:.3f}"
                )
            else:
                pass

    def calculate_strength_difference_method_2(self):
        """
        Метод 2. Аналогично, но с другой логикой.
        """
        for game in self.games:
            league_name = game['league']
            home_team   = game['home_team']
            away_team   = game['away_team']
            home_odds   = game['home_odds']
            away_odds   = game['away_odds']

            threshold_home, threshold_away = league_thresholds.get(league_name, (2.40, 3.00))

            if home_odds < away_odds:
                # хозяева считаются фаворитом
                if home_odds < threshold_home:
                    home_strength = abs((100 / threshold_home) - (100 / home_odds))
                    self.equations_method_2.append(
                        f"{home_team} = {away_team} + {home_strength:.3f}"
                    )
                else:
                    home_strength = abs((100 / home_odds) - (100 / threshold_home))
                    self.equations_method_2.append(
                        f"{away_team} = {home_team} + {home_strength:.3f}"
                    )
            else:
                # гости считаются фаворитом
                if away_odds < threshold_away:
                    away_strength = abs((100 / threshold_away) - (100 / away_odds))
                    self.equations_method_2.append(
                        f"{away_team} = {home_team} + {away_strength:.3f}"
                    )
                else:
                    away_strength = abs((100 / away_odds) - (100 / threshold_away))
                    self.equations_method_2.append(
                        f"{home_team} = {away_team} + {away_strength:.3f}"
                    )

    def simplify_with_sympy(self, start_team, end_team):
        """
        Решаем сформированные «уравнения» и вычисляем разницу сил между start_team и end_team.
        В этом методе также берём пороги исходя из лиги первого матча в self.games
        (если в цепочке несколько лиг – используем первую).
        """
        if not self.games:
            print("Нет матчей для расчета.")
            return []

        # Лига первого матча (если цепочка состоит из нескольких лиг, берём первую)
        first_league = self.games[0]['league']
        threshold_home, threshold_away = league_thresholds.get(first_league, (2.40, 3.00))

        # Создаём символы для каждой команды
        team_symbols = {}
        for team in self.teams:
            if team == start_team:
                team_symbols[team] = 0
            else:
                safe_name = team.replace(' ', '_').replace('-', '_')
                team_symbols[team] = symbols(safe_name)

        # Преобразуем equations_method_1 в список уравнений SymPy
        sympy_equations_method_1 = []
        for equation in self.equations_method_1:
            parts = equation.split('=')
            if len(parts) == 2 and '+' in parts[1]:
                left_team, right = parts[0].strip(), parts[1].strip()
                right_team, strength_diff = right.split('+')
                right_team = right_team.strip()
                strength_diff = float(strength_diff.strip())
                left_sym = team_symbols[left_team]
                right_sym = team_symbols[right_team]
                sympy_equations_method_1.append(Eq(left_sym, right_sym + strength_diff))

        # Преобразуем equations_method_2 в список уравнений SymPy
        sympy_equations_method_2 = []
        for equation in self.equations_method_2:
            parts = equation.split('=')
            if len(parts) == 2 and '+' in parts[1]:
                left_team, right = parts[0].strip(), parts[1].strip()
                right_team, strength_diff = right.split('+')
                right_team = right_team.strip()
                strength_diff = float(strength_diff.strip())
                left_sym = team_symbols[left_team]
                right_sym = team_symbols[right_team]
                sympy_equations_method_2.append(Eq(left_sym, right_sym + strength_diff))

        # Формируем список символов (исключая те, что зафиксированы = 0)
        symbols_list = [sym for sym in team_symbols.values() if sym != 0]

        # Решение уравнений
        solution_1 = solve(sympy_equations_method_1, symbols_list, dict=True) if sympy_equations_method_1 else []
        solution_2 = solve(sympy_equations_method_2, symbols_list, dict=True) if sympy_equations_method_2 else []

        # Ищем символ для end_team
        end_symbol = team_symbols.get(end_team)
        final_results = []

        # --- Обработка результатов метода 1 ---
        if solution_1 and end_symbol is not None:
            sol = solution_1[0]
            if end_symbol in sol:
                end_value = sol[end_symbol]
                try:
                    end_value_numeric = float(end_value.evalf())
                    strength_diff = -end_value_numeric
                    new_odds_start = 100 / ((100 / threshold_home) + strength_diff)
                    new_odds_end   = 100 / ((100 / threshold_home) - strength_diff)
                    final_results.append(
                        f"Method 1: {start_team} = {end_team} + {strength_diff:.3f}; "
                        f"{start_team} odds = {new_odds_start:.3f}; {end_team} odds = {new_odds_end:.3f}"
                    )
                except (TypeError, ValueError):
                    print(f"Не удалось вычислить численное значение силы {end_team} в методе 1.")
            else:
                print(f"Команда {end_team} не найдена в решении метода 1.")
        else:
            print("Нет решения для метода 1.")

        # --- Обработка результатов метода 2 ---
        if solution_2 and end_symbol is not None:
            sol = solution_2[0]
            if end_symbol in sol:
                end_value = sol[end_symbol]
                try:
                    end_value_numeric = float(end_value.evalf())
                    strength_diff = -end_value_numeric
                    new_odds_start = 100 / ((100 / threshold_home) + strength_diff)
                    new_odds_end   = 100 / ((100 / threshold_home) - strength_diff)
                    final_results.append(
                        f"Method 2: {start_team} = {end_team} + {strength_diff:.3f}; "
                        f"{start_team} odds = {new_odds_start:.3f}; {end_team} odds = {new_odds_end:.3f}"
                    )
                except (TypeError, ValueError):
                    print(f"Не удалось вычислить численное значение силы {end_team} в методе 2.")
            else:
                print(f"Команда {end_team} не найдена в решении метода 2.")
        else:
            print("Нет решения для метода 2.")

        # Вывод итоговых результатов
        if final_results:
            for result in final_results:
                print(result)
        else:
            print("Не удалось вычислить разницу в силе между командами.")

        return final_results

# ===== ДОБАВЛЕНО: собираем текст отчёта (для Excel "как Word") =====
report_lines = []
report_lines.append(f"RUN: {datetime.now().strftime('%d.%m.%Y %H:%M:%S')}")
report_lines.append(f"Источник данных: {excel_file_path}")
report_lines.append("Запросы:")
for i, (a, b) in enumerate(team_pairs, start=1):
    report_lines.append(f"  {i}) {a} -> {b}")
report_lines.append("-" * 80)
# ===== КОНЕЦ ДОБАВЛЕНИЯ =====

# ===== ДОБАВЛЕНО: обработка сразу нескольких пар (или одной) =====
for request_num, (start_team, end_team) in enumerate(team_pairs, start=1):

    # Поиск цепочек между двумя заданными командами
    chains = find_chains(matches, start_team, end_team)

    # Удаляем дубликаты цепочек
    unique_chains = []
    seen_chains = set()

    for chain in chains:
        chain_tuple = tuple(chain)
        if chain_tuple not in seen_chains:
            seen_chains.add(chain_tuple)
            unique_chains.append(chain)

    chains = unique_chains

    report_lines.append(f"\n[Запрос {request_num}] {start_team} -> {end_team}")

    # Если цепочки найдены
    if chains:
        # Группируем цепочки по длине
        chain_groups = {}
        for chain in chains:
            chain_length = len(chain)
            if chain_length not in chain_groups:
                chain_groups[chain_length] = []

            # Вычисляем «среднюю дату» в цепочке (для сортировки от более новых к старым)
            dates = []
            for match in chain:
                raw_date = match[1]
                date_obj = None

                if isinstance(raw_date, datetime):
                    date_obj = raw_date
                elif isinstance(raw_date, (float, int)):
                    try:
                        date_obj = datetime(1899, 12, 30) + timedelta(days=int(raw_date))
                    except:
                        date_obj = None
                elif isinstance(raw_date, str):
                    try:
                        if ' - ' in raw_date:
                            date_part = raw_date.split(' - ')[0].strip()
                            date_obj = datetime.strptime(date_part, '%d.%m.%Y')
                        else:
                            date_obj = datetime.strptime(raw_date.strip(), '%d.%m.%Y')
                    except:
                        date_obj = None

                if date_obj:
                    dates.append(date_obj)
                else:
                    print(f"Не удалось интерпретировать дату: {raw_date}")

            if dates:
                avg_timestamp = sum(d.timestamp() for d in dates) / len(dates)
                avg_date = datetime.fromtimestamp(avg_timestamp)
                chain_groups[chain_length].append({'chain': chain, 'avg_date': avg_date})
            else:
                chain_groups[chain_length].append({'chain': chain, 'avg_date': datetime.min})

        # Сортируем цепочки в каждой группе по средней дате (от более свежей к более старой)
        for chain_length in sorted(chain_groups.keys()):
            chain_infos = chain_groups[chain_length]
            chain_infos_sorted = sorted(chain_infos, key=lambda x: x['avg_date'], reverse=True)
            chain_groups[chain_length] = chain_infos_sorted

        chain_index = 1
        for chain_length in sorted(chain_groups.keys()):
            print(f"\n=== (Запрос {request_num}) {start_team} -> {end_team} | Цепочки из {chain_length} WTP ===\n")
            report_lines.append(f"\n=== Цепочки из {chain_length} WTP ===")

            chain_infos = chain_groups[chain_length]
            for chain_info in chain_infos:
                chain = chain_info['chain']
                avg_date = chain_info['avg_date']
                avg_date_str = avg_date.strftime('%d.%m.%Y') if avg_date != datetime.min else ""

                print(f"Цепочка {chain_index} (Средняя дата: {avg_date_str}):")
                report_lines.append(f"\nЦепочка {chain_index} (Средняя дата: {avg_date_str}):")

                # Собираем матчи и лиги
                games = []
                used_leagues = set()

                report_lines.append("Матчи:")
                for match in chain:
                    league, date, home_team, away_team, odds1, odds_draw, odds2 = match
                    print(f"('{date}', '{home_team}', '{away_team}', {odds1}, {odds_draw}, {odds2})")
                    report_lines.append(f"('{date}', '{home_team}', '{away_team}', {odds1}, {odds_draw}, {odds2})")
                    games.append(match)
                    used_leagues.add(league)

                print("\nИспользуемые лиги в цепочке и их пороги:")
                report_lines.append("\nИспользуемые лиги в цепочке и их пороги:")
                for lg in sorted(used_leagues):
                    th_home, th_away = league_thresholds.get(lg, (2.40, 3.00))
                    print(f"    Лига: {lg} → home={th_home}, away={th_away}")
                    report_lines.append(f"    Лига: {lg} → home={th_home}, away={th_away}")

                # Расчет и вывод методов
                calculator = TeamStrengthCalculator()
                calculator.add_games(games)
                calculator.calculate_strength_difference_method_1()
                calculator.calculate_strength_difference_method_2()
                final_results = calculator.simplify_with_sympy(start_team, end_team)

                report_lines.append("\nРезультаты:")
                if final_results:
                    for r in final_results:
                        report_lines.append(r)
                else:
                    report_lines.append("Не удалось вычислить разницу в силе между командами.")

                print("\n" + "="*75 + "\n")
                report_lines.append("\n" + "=" * 75)

                chain_index += 1
    else:
        print(f"Не найдены WTP-цепочки между указанными командами: {start_team} -> {end_team}")
        report_lines.append("Не найдены WTP-цепочки между указанными командами.")
# ===== КОНЕЦ ДОБАВЛЕНИЯ =====

# ===== ДОБАВЛЕНО: сохраняем в ОДИН файл и дописываем =====
out_dir = os.path.dirname(excel_file_path) if os.path.dirname(excel_file_path) else os.getcwd()
output_excel_path = os.path.join(out_dir, "wtp_results.xlsx")

final_text_block = "\n".join(report_lines)
append_text_report_to_excel(output_excel_path, final_text_block)

print(f"\nГотово. Результаты ДОПИСАНЫ в Excel:\n{output_excel_path}")
# ===== КОНЕЦ ДОБАВЛЕНИЯ =====