// SettlementDiplomacy.cs - Логика поиска поселений и дипломатии
using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using System.Collections.Generic;
using UnityEngine.SceneManagement;
using TMPro;

public class SettlementDiplomacy : MonoBehaviour
{
    public Button diplomacyButton; // Кнопка "Дипломатия" x
    public GameObject findSettlementPanel; // Панель поиска поселений x
    public Text findSettlementText; // Текст на панели поиска x
    public Image progressBar; // Индикатор прогресса поиска x
    public GameObject diplomacyPanel; // Панель дипломатии с найденным поселением x
    public Text settlementNameText; // Текст с названием поселения x
    public Text settlementPopulationText; // Текст с количеством жителей поселения x
    public Text settlementRelationText; // Текст с отношением к поселению x
    public Text settlementBuildingMaterialsText; // Текст с инфой о кол-ве стройматериалов
    public Text settlementFoodText; // Текст с инфой о кол-ве еды
    public Text settlementGoldText; // Текст с инфой о кол-ве монет
    public Text settlementWeaponsText; // Текст с инфой о кол-ве оружия и боеприпасов
    public Text settlementDescriptionText; // Текст с описанием поселения x
    public Button tradeButton; // Кнопка "Обмен опытом"
    public Button improveRelationButton; // Кнопка "Улучшить отношения"
    public Button conquerButton; // Кнопка "Захватить"
    public Button ignoreButton; // Кнопка "Обойти стороной"
    public GameObject gameOverPanel; // Панель Game Over
    public Text gameOverText; // Текст на панели Game Over
    public Button mainMenuButton; // Кнопка "Главное меню"

    public GameObject settlementsListPanel; // Панель списка поселений
    public Transform settlementsListContent; // Контент списка поселений (место для элементов списка)
    public GameObject settlementListItemPrefab; // Префаб элемента списка поселений
    public Button closeListButton; // Закрываем список поселений

    public GameManager gameManager; // Ссылка на GameManager

    private List<Settlement> settlements = new List<Settlement>(); // Список найденных поселений
    private List<Settlement> activeTrades = new List<Settlement>(); //
    private Settlement currentSettlement; // Текущее выбранное поселение

    public GameObject battlePanel;       // Панель выбора тактики
    public Button assaultButton;        // Кнопка "Штурм"
    public Button siegeButton;          // Кнопка "Осада"
    public Button sabotageButton;       // Кнопка "Диверсия"
    private bool isWarInProgress = false; // Флаг для отслеживания войны

    private Coroutine tradeCoroutine; // Отслеживание корутины обмена опытом

    public Button buttonOpenSettlementsList; // Кнопка для открытия списка поселений
    private bool isSettlementsListOpen = false;

    private const int MAX_SETTLEMENTS = 5; // Ограничение на количество поселений

    public GameObject relationRequestPanel; // Ссылка на панель RelationRequestUI

    private Dictionary<Settlement, Coroutine> tradeCoroutines = new Dictionary<Settlement, Coroutine>(); // Словарь для хранения корутин

    private void UpdateSettlementsListButtonVisibility() // Метод каждый раз, когда добавляете новое поселение
    {
        buttonOpenSettlementsList.gameObject.SetActive(settlements.Count > 0);
    }

    // Метод при нажатии на кнопку buttonOpenSettlementsList
    private void OnOpenSettlementsListButtonClicked()
    {
        isSettlementsListOpen = !isSettlementsListOpen;
        settlementsListPanel.SetActive(isSettlementsListOpen);
    }

    // Изменяем struct на class
    [System.Serializable]
    public class Settlement
    {
        public string name;
        public int population;
        public SettlementRelation relation;
        public string description;
        public SettlementStatus status;

        // Ресурсы найденого поселения
        public int buildingMaterials = 0;
        public int food = 0;
        public int gold = 0;
        public int weapons = 0;

        public int improveAttempts = 0; // Количество попыток улучшения отношений
    }

    // Перечисление для отношения к поселению
    public enum SettlementRelation
    {
        Hostile,
        Neutral,
        Friendly
    }

    // Перечисление для статуса отношений с поселением
    public enum SettlementStatus
    {
        None,
        Trade,
        War
    }

    void Start()
    {
        diplomacyButton.onClick.AddListener(StartFindSettlement);
        diplomacyPanel.SetActive(false);
        gameOverPanel.SetActive(false);

        // Проверяем, назначена ли кнопка в инспекторе
        if (mainMenuButton != null)
        {
            // Добавляем обработчик события OnClick
            mainMenuButton.onClick.AddListener(GoToMainMenu);
        }
        else
        {
            Debug.LogError("Ошибка: кнопка 'mainMenuButton' не назначена в инспекторе!");
        }

        // Назначаем обработчики кнопок один раз при старте
        tradeButton.onClick.AddListener(OnTradeButtonClicked);
        improveRelationButton.onClick.AddListener(OnImproveRelationButtonClicked);
        conquerButton.onClick.AddListener(OnConquerButtonClicked);
        ignoreButton.onClick.AddListener(IgnoreSettlement);
        closeListButton.onClick.AddListener(CloseList);
        buttonOpenSettlementsList.onClick.AddListener(OnOpenSettlementsListButtonClicked);

        currentSettlement = new Settlement(); // Инициализируем структуру
    }

    // Начало поиска поселения
    private void StartFindSettlement()
    {
        // Проверяем, не достигнуто ли максимальное количество поселений
        if (settlements.Count >= MAX_SETTLEMENTS)
        {
            findSettlementPanel.SetActive(true);
            findSettlementText.text = "Вы достигли максимального количества поселений для взаимодействия";
            progressBar.fillAmount = 0f; // Можно скрыть progressBar, если нужно
            StartCoroutine(HideFindSettlementPanel(2f)); // Скрываем панель через 2 секунды
            return; // Выходим из метода
        }

        findSettlementPanel.SetActive(true);
        findSettlementText.text = "Поиск поселений...";
        progressBar.fillAmount = 0f;
        // 1. Влияние размера населения на шанс найти поселение:
        float populationFactor = Mathf.Clamp01(gameManager.population / 500f); // от 0 до 1, где 500 - "идеальное" население для поиска
        float findChance = 0.5f + populationFactor * 0.3f; // Базовый шанс + бонус от населения (до 30%)

        // 2. Влияние счастья на шанс успеха поиска:
        float happinessFactor = Mathf.Clamp01(gameManager.happiness / 100f);
        findChance += happinessFactor * 0.2f; // Дополнительный бонус от счастья (до 20%)

        // 3. Разные варианты провала поиска:
        string[] failMessages = {
            "Отряд поисковиков погиб! -6 человек и -3 счастья населения",
            "Поисковики вернулись ни с чем. -1 счастье населения",
            "Обнаружены следы поселения, но оно оказалось заброшено. -2 счастья населения",
            // ... больше вариантов!
        };

        StartCoroutine(FindSettlement(findChance, failMessages));
    }

    // Корутина для имитации поиска поселения
    private IEnumerator FindSettlement(float successChance, string[] failMessages)
    {
        float timer = 0f;
        while (timer < 5f)
        {
            timer += Time.deltaTime;
            progressBar.fillAmount = timer / 5f;
            yield return null;
        }

        // После завершения поиска - рандомный результат
        if (Random.value < successChance)
        {
            findSettlementText.text = "Мы нашли поселение!";
            Settlement newSettlement = GenerateSettlement();
            settlements.Add(newSettlement);
            OpenDiplomacyPanel(newSettlement);
        }
        else
        {
            // Выбираем случайное сообщение о провале:
            string failMessage = failMessages[Random.Range(0, failMessages.Length)];
            findSettlementText.text = failMessage;

            // Применяем последствия провала в зависимости от сообщения:
            if (failMessage.Contains("погиб"))
            {
                gameManager.population -= 6;
                gameManager.happiness -= 3;
            }
            else if (failMessage.Contains("счастье"))
            {
                // Извлекаем число из строки (например, "-3" из " -3 счастья населения")
                int happinessChange = int.Parse(failMessage.Substring(failMessage.IndexOf('-') + 1, 1));
                gameManager.happiness += happinessChange; // Обратите внимание на "+" - мы уменьшаем счастье
            }

            gameManager.UpdatePopulationText();
            gameManager.UpdateHappinessText();
        }

        yield return new WaitForSeconds(2f); // Пауза для просмотра результата
        findSettlementPanel.SetActive(false); // Скрываем панель поиска
    }

    // Корутина для скрытия панели поиска
    private IEnumerator HideFindSettlementPanel(float delay)
    {
        yield return new WaitForSeconds(delay);
        findSettlementPanel.SetActive(false);
    }

    // Генерация случайного поселения
    private Settlement GenerateSettlement()
    {
        Settlement settlement = new Settlement();

        // Список имён для поселений
        string[] settlementNames = {
            "Союз Выживших", "Братство Воды", "Стальной Кулак",
            "Новое Начало", "Оазис Надежды", "Стражи Свободы",
            "Дети Атома", "Хранители Знаний", "Потомки Солнца",
            "Лига Справедливости", "Анклав" // Добавьте больше имён по желанию!
        };

        // Список описаний для поселений
        string[] settlementDescriptions = {
            "Мирное поселение тороговцев и ремесленников.",
            "Группа воинов, защищающих слабые поселения.",
            "Поселение обосновалось вокруг старого военного бункера.",
            // ... добавьте больше описаний!
        };

        settlement.name = settlementNames[Random.Range(0, settlementNames.Length)];
        settlement.population = Random.Range(100, 1000);
        settlement.relation = (SettlementRelation)Random.Range(0, 3);
        settlement.description = settlementDescriptions[Random.Range(0, settlementDescriptions.Length)];
        settlement.status = SettlementStatus.None;

        settlement.buildingMaterials = Random.Range(50, 200);
        settlement.food = Random.Range(30, 150);
        settlement.gold = Random.Range(20, 100);
        settlement.weapons = Random.Range(10, 50);

        return settlement;
    }

    // Открытие панели дипломатии
    private void OpenDiplomacyPanel(Settlement settlement)
    {
        currentSettlement = settlement; // Сохраняем текущее поселение

        diplomacyPanel.SetActive(true);
        settlementNameText.text = settlement.name;
        settlementPopulationText.text = "Население: " + settlement.population;
        settlementRelationText.text = "Отношение: " + GetRelationText(settlement.relation); // Перевод отношения
        settlementDescriptionText.text = settlement.description;
        settlementDescriptionText.text += "\nСтатус: " + GetStatusText(settlement.status); // Перевод статуса
        settlementBuildingMaterialsText.text = "Стройматериалы: " + settlement.buildingMaterials;
        settlementFoodText.text = "Еда: " + settlement.food;
        settlementGoldText.text = "Монеты: " + settlement.gold;
        settlementWeaponsText.text = "Оружие и боеприпасы: " + settlement.weapons;

        // Обновляем доступность кнопки "Обмен опытом"
        tradeButton.interactable = settlement.relation == SettlementRelation.Friendly && !activeTrades.Contains(settlement);

        // Обновляем доступность кнопки "Улучшить отношения"
        improveRelationButton.interactable = settlement.relation != SettlementRelation.Friendly;

        // Ищем компонент TMP_Text на кнопке или её потомках
        TMP_Text tradeButtonText = tradeButton.GetComponentInChildren<TMP_Text>();

        // Проверяем, найден ли компонент TMP_Text
        if (tradeButtonText != null)
        {
            tradeButtonText.color = settlement.relation == SettlementRelation.Friendly ? Color.white : Color.gray;
        }
        else
        {
            Debug.LogError("Компонент TMP_Text не найден на кнопке 'tradeButton' или её потомках!");
        }

        UpdateConquerButtonInteractable();
        UpdateImproveRelationButtonInteractable();
        UpdateTradeButtonInteractable();

        UpdateSettlementsListButtonVisibility(); // Обновляем видимость кнопки 

        // Если список поселений открыт, закрываем его
        if (isSettlementsListOpen)
        {
            isSettlementsListOpen = false;
            settlementsListPanel.SetActive(false);
        }
    }

    // Функция для получения текста отношения на русском
    private string GetRelationText(SettlementRelation relation)
    {
        switch (relation)
        {
            case SettlementRelation.Hostile:
                return "Враждебное";
            case SettlementRelation.Neutral:
                return "Нейтральное";
            case SettlementRelation.Friendly:
                return "Дружеское";
            default:
                return "Неизвестно"; // Или другое значение по умолчанию
        }
    }

    // Функция для получения текста статуса на русском
    private string GetStatusText(SettlementStatus status)
    {
        switch (status)
        {
            case SettlementStatus.None:
                return "Нет";
            case SettlementStatus.Trade:
                return "Обмен опытом";
            case SettlementStatus.War:
                return "Война";
            default:
                return "Неизвестно"; // Или другое значение по умолчанию
        }
    }

    private void UpdateImproveRelationButtonInteractable()
    {
        improveRelationButton.interactable = currentSettlement != null &&
                                            currentSettlement.relation != SettlementRelation.Friendly;
    }


    private void UpdateTradeButtonInteractable()
    {
        tradeButton.interactable = currentSettlement != null &&
                                   currentSettlement.relation == SettlementRelation.Friendly &&
                                   !activeTrades.Contains(currentSettlement);
    }

    // Обработчики кнопок
    private void OnTradeButtonClicked()
    {
        if (tradeButton.interactable)
        {
            activeTrades.Add(currentSettlement);
            UpdateSettlementStatus(currentSettlement.name, SettlementStatus.Trade);

            // Запускаем корутину и сохраняем её в словаре:
            Coroutine newTradeCoroutine = StartCoroutine(TradeExperience(currentSettlement));
            tradeCoroutines[currentSettlement] = newTradeCoroutine;

            OpenSettlementsListPanel();
            diplomacyPanel.SetActive(false);
            currentSettlement = null;
        }
    }

    /*private void OnImproveRelationButtonClicked()
    {
        if (improveRelationButton.interactable)
        {
            ImproveRelation(currentSettlement);
            UpdateSettlementStatus(currentSettlement.name, SettlementStatus.None);
            OpenSettlementsListPanel();
            diplomacyPanel.SetActive(false);
            currentSettlement = null;
        }
    }*/

    private void OnImproveRelationButtonClicked()
    {
        if (improveRelationButton.interactable)
        {
            // Проверяем, не превышено ли количество попыток
            if (currentSettlement.improveAttempts >= 1)
            {
                Debug.Log("Вы уже пытались улучшить отношения с этим поселением.");
                return; // Выходим из метода
            }

            // 1. Проверка шансов
            float randomValue = Random.value;

            if (randomValue < 0.05f) // 5% шанс гибели переговорщиков
            {
                gameManager.population -= 10;
                gameManager.UpdatePopulationText();
                Debug.Log("Ваши переговорщики были убиты.");

                currentSettlement.relation = SettlementRelation.Hostile; // Отношения становятся враждебными
                UpdateConquerButtonInteractable(); // Активируем кнопку "Захватить", если возможно
                improveRelationButton.interactable = false; // Деактивируем кнопку "Улучшить отношения"
            }
            else if (randomValue < 0.25f) // 20% шанс отказа
            {
                Debug.Log("Это поселение отказалось вести с вами переговоры.");
            }
            else // 75% шанс запроса ресурсов
            {
                // 2. Генерация запроса ресурсов
                ResourceRequest request = GenerateResourceRequest(currentSettlement);

                // 3. Отображение запроса на панели
                relationRequestPanel.SetActive(true);
                relationRequestPanel.GetComponentInChildren<Text>().text = GetRequestText(request);

                // 4. Обработка кнопок "Согласиться" и "Отказаться"
                Button agreeButton = relationRequestPanel.transform.Find("AgreeButton").GetComponent<Button>();
                Button refuseButton = relationRequestPanel.transform.Find("RefuseButton").GetComponent<Button>();

                agreeButton.interactable = CanFulfillRequest(request);

                agreeButton.onClick.RemoveAllListeners();
                agreeButton.onClick.AddListener(() =>
                {
                    if (CanFulfillRequest(request))
                    {
                        FulfillRequest(request);

                        // Гарантированно улучшаем отношения:
                        currentSettlement.relation = SettlementRelation.Friendly;
                        settlementRelationText.text = "Отношение: " + GetRelationText(currentSettlement.relation);

                        relationRequestPanel.SetActive(false);
                        OpenSettlementsListPanel();
                        diplomacyPanel.SetActive(false);
                        currentSettlement = null;
                    }
                });

                refuseButton.onClick.RemoveAllListeners();
                refuseButton.onClick.AddListener(() =>
                {
                    relationRequestPanel.SetActive(false);
                    // Поселение не добавляется в список
                });
            }

            currentSettlement.improveAttempts++;
        }
    }

    // Структура для запроса ресурсов
    public struct ResourceRequest
    {
        public int buildingMaterials;
        public int food;
        public int gold;
        public int weapons;
    }

    // Метод для генерации запроса ресурсов
    private ResourceRequest GenerateResourceRequest(Settlement settlement)
    {
        ResourceRequest request = new ResourceRequest();
        int resourceTypes = Random.Range(1, 5); // От 1 до 4 типов ресурсов

        for (int i = 0; i < resourceTypes; i++)
        {
            int resourceType = Random.Range(0, 4); // Случайный выбор типа ресурса

            switch (resourceType)
            {
                case 0: request.buildingMaterials = Random.Range(50, 201); break; // 50 - 200
                case 1: request.food = Random.Range(30, 151); break; // 30 - 150
                case 2: request.gold = Random.Range(20, 101); break; // 20 - 100
                case 3: request.weapons = Random.Range(10, 51); break; // 10 - 50
            }
        }

        return request;
    }

    // Метод для проверки, может ли игрок выполнить запрос
    private bool CanFulfillRequest(ResourceRequest request)
    {
        return gameManager.resources.buildingMaterials >= request.buildingMaterials &&
               gameManager.resources.food >= request.food &&
               gameManager.resources.gold >= request.gold &&
               gameManager.resources.weapons >= request.weapons;
    }

    // Метод для выполнения запроса (вычитание ресурсов)
    private void FulfillRequest(ResourceRequest request)
    {
        gameManager.resources.buildingMaterials -= request.buildingMaterials;
        gameManager.resources.food -= request.food;
        gameManager.resources.gold -= request.gold;
        gameManager.resources.weapons -= request.weapons;
        gameManager.resources.UpdateResourceUI();
    }

    // Метод для формирования текста запроса
    private string GetRequestText(ResourceRequest request)
    {
        string text = "Мы согласны улучшить с вами отношения за:\n";

        if (request.buildingMaterials > 0) text += $"{request.buildingMaterials} стройматериалов\n";
        if (request.food > 0) text += $"{request.food} еды\n";
        if (request.gold > 0) text += $"{request.gold} монет\n";
        if (request.weapons > 0) text += $"{request.weapons} оружия\n";

        return text;
    }

    private void OnConquerButtonClicked()
    {
        if (currentSettlement != null && conquerButton.interactable)
        {
            // Вместо начала боя, показываем панель выбора тактики:
            UpdateSettlementStatus(currentSettlement.name, SettlementStatus.War);
            battlePanel.SetActive(true);
            diplomacyPanel.SetActive(false);

            // Назначаем обработчики кнопок тактики
            assaultButton.onClick.AddListener(() =>
                StartCoroutine(ConquerSettlement(currentSettlement, "Assault")));
            siegeButton.onClick.AddListener(() =>
                StartCoroutine(ConquerSettlement(currentSettlement, "Siege")));
            sabotageButton.onClick.AddListener(() =>
                StartCoroutine(ConquerSettlement(currentSettlement, "Sabotage")));
        }
        else if (isWarInProgress)
        {
            Debug.Log($"Война с {currentSettlement.name} уже идет!");
        }
        else if (gameManager.population < currentSettlement.population)
        {
            Debug.Log($"У вас недостаточно населения для войны с {currentSettlement.name}!");
        }
    }

    private void UpdateConquerButtonInteractable()
    {
        conquerButton.interactable = currentSettlement != null &&
                                     gameManager.population >= currentSettlement.population &&
                                     currentSettlement.relation == SettlementRelation.Hostile &&
                                     !isWarInProgress;
    }

    // Обмен опытом
    private void StartTrade(Settlement settlement)
    {
        // Проверяем, что отношения с поселением дружественные
        if (settlement.relation == SettlementRelation.Friendly)
        {
            // Запускаем корутину для обмена опытом
            StartCoroutine(TradeExperience(settlement));
        }
    }

    private IEnumerator TradeExperience(Settlement settlement)
    {
        // Проверка условий для обмена
        if (settlement.relation != SettlementRelation.Friendly || !activeTrades.Contains(settlement))
        {
            Debug.Log("Невозможно обмениватсья опытом с поселением, без дружеских отношений.");
            yield break; // Прекращаем корутину
        }

        while (activeTrades.Contains(settlement)) // Цикл продолжается, пока есть торговля
        {
            gameManager.population += 5;
            gameManager.happiness += 10;
            gameManager.UpdatePopulationText();
            gameManager.UpdateHappinessText();

            // Добавить звук или анимацию для обмена

            yield return new WaitForSeconds(30);
        }
    }

    // Улучшение отношений
    private void ImproveRelation(Settlement settlement)
    {
        if (settlement.relation == SettlementRelation.Hostile)
        {
            // Попытка установить нейтральные отношения
            settlement.relation = SettlementRelation.Neutral;
            settlementRelationText.text = "Отношение: " + SettlementRelation.Neutral;

            // Вывод сообщения о том, что отношения стали нейтральными
            Debug.Log($"Отношения с {settlement.name} стали нейтральными.");

            // Добавьте визуальный эффект или звук для изменения отношений
        }
        else if (settlement.relation == SettlementRelation.Neutral)
        {
            // Попытка установить дружеские отношения
            // 50/50 шанс успеха
            if (Random.value < 0.5f)
            {
                settlement.relation = SettlementRelation.Friendly;
                settlementRelationText.text = "Отношение: " + SettlementRelation.Friendly;
                gameManager.happiness += 5;
                gameManager.UpdateHappinessText();

                OpenDiplomacyPanel(settlement);

                // Вывод сообщения о том, что отношения стали дружескими
                Debug.Log($"Отношения с {settlement.name} стали дружескими.");

                // Добавьте визуальный эффект или звук для изменения отношений
            }
            else
            {
                // Отношения остаются нейтральными
                settlementRelationText.text = "Отношение: " + SettlementRelation.Neutral;
                gameManager.happiness -= 3;
                gameManager.UpdateHappinessText();

                // Вывод сообщения о том, что отношения не изменились
                Debug.Log($"Попытка улучшить отношения с {settlement.name} провалилась.");

                // Добавьте визуальный эффект или звук для провала попытки
            }
        }
        else if (settlement.relation == SettlementRelation.Friendly)
        {
            // Вывод сообщения о том, что отношения уже дружеские
            Debug.Log($"Отношения с {settlement.name} уже дружеские.");
        }
    }

    // Начало захвата
    private void StartConquest(Settlement settlement, string tactic)
    {
        // Проверяем, что отношения с поселением враждебные
        if (settlement.relation == SettlementRelation.Hostile)
        {
            settlement.status = SettlementStatus.War;
            StartCoroutine(ConquerSettlement(settlement, tactic)); // Передаём tactic
        }
    }

    // Корутина для захвата поселения (с выбором тактики)
    private IEnumerator ConquerSettlement(Settlement settlement, string tactic)
    {
        isWarInProgress = true;
        battlePanel.SetActive(false); // Скрываем панель выбора

        // Базовый шанс на победу
        /* float winChance = Mathf.Clamp01((float)gameManager.population /
                                        (float)(gameManager.population + settlement.population)); */
        float winChance = Mathf.Clamp01((float)(gameManager.population + gameManager.resources.weapons) /
                                (float)(gameManager.population + settlement.population + (settlement.population / 2)));
        // Пример: добавляем к силе игрока его оружие, а к силе противника - половину его населения (как грубую оценку вооружения)

        // Модификаторы шанса и потерь в зависимости от тактики
        float winChanceModifier = 0f;
        float playerLossModifier = 1f;
        float enemyLossModifier = 1f;

        switch (tactic)
        {
            case "Assault":
                winChanceModifier = 0.15f;  // +15% к шансу победы
                playerLossModifier = 1.5f; // +50% к потерям игрока
                enemyLossModifier = 2f;    // x2 к потерям противника
                                           // Дополнительный текст или эффекты для штурма
                Debug.Log("Вы начали яростный штурм поселения!");
                break;
            case "Siege":
                winChanceModifier = -0.1f;   // -10% к шансу победы
                playerLossModifier = 0.7f; // -30% к потерям игрока
                enemyLossModifier = 0.8f; // -20% к потерям противника
                                          // Дополнительный текст или эффекты для осады
                Debug.Log("Вы окружили поселение и начали осаду!");
                yield return new WaitForSeconds(2f); // Имитация долгой подготовки
                break;
            case "Sabotage":
                // Диверсия не влияет на шанс победы напрямую, 
                // но уменьшает население противника перед битвой
                int sabotageLosses = Mathf.RoundToInt(settlement.population * 0.1f); // 10%
                settlement.population -= sabotageLosses;
                settlementPopulationText.text = "Население: " + settlement.population; // Обновляем UI
                                                                                       // Дополнительный текст или эффекты для диверсии
                Debug.Log("Ваши диверсанты проникли в поселение!");
                yield return new WaitForSeconds(2f); // Задержка для имитации диверсии
                break;
        }

        // Применяем модификаторы
        winChance += winChanceModifier;
        winChance = Mathf.Clamp01(winChance);

        // Имитируем битву (например, текстом в UI)
        Debug.Log("Идет ожесточенная битва!...");
        yield return new WaitForSeconds(2f);

        // Определяем исход битвы 
        bool isVictory = Random.value < winChance;

        if (isVictory)
        {
            // Логика победы:
            settlement.status = SettlementStatus.None;

            // Передача ресурсов победителю:
            gameManager.resources.buildingMaterials += settlement.buildingMaterials;
            gameManager.resources.food += settlement.food;
            gameManager.resources.gold += settlement.gold;
            gameManager.resources.weapons += Mathf.RoundToInt(settlement.weapons * 0.5f); // Добавляем 50% оружия

            // Обнуляем ресурсы побеждённого поселения:
            settlement.buildingMaterials = 0;
            settlement.food = 0;
            settlement.gold = 0;
            settlement.weapons = Mathf.RoundToInt(settlement.weapons * 0.5f); // Оставляем 50% оружия у проигравшего поселения

            // Население присоединившегося поселения (часть от начального)
            int joinedPopulation = Mathf.RoundToInt(settlement.population * 0.7f);
            gameManager.population += joinedPopulation;

            settlement.population = joinedPopulation;
            settlement.relation = SettlementRelation.Friendly;
            settlement.description = "Поселение присоединилось к вам!";

            // Обновление интерфейса
            settlementRelationText.text = "Отношение: " + SettlementRelation.Friendly;
            settlementDescriptionText.text = "Поселение захвачено!";
            settlementBuildingMaterialsText.text = "Стройматериалы: " + settlement.buildingMaterials; // Обновляем на панели дипломатии
            settlementFoodText.text = "Еда: " + settlement.food;
            settlementGoldText.text = "Монеты: " + settlement.gold;

            settlements.Remove(settlement);

            Debug.Log("Победа! Поселение захвачено!");

            // Обновляем интерфейс ресурсов игрока:
            gameManager.resources.UpdateResourceUI();
        }
        else
        {
            // Логика поражения:
            int playerLosses = Mathf.RoundToInt(gameManager.population * 0.3f * playerLossModifier);
            gameManager.population -= playerLosses;

            // Потери противника (ИСПОЛЬЗУЕМ enemyLossModifier)
            int enemyLosses = Mathf.RoundToInt(settlement.population * 0.2f * enemyLossModifier);
            settlement.population -= enemyLosses;
            settlementPopulationText.text = "Население: " + settlement.population; // Обновляем UI

            // Дополнительные действия при поражении (например, изменение отношений)
            settlement.relation = SettlementRelation.Hostile;
            settlementRelationText.text = "Отношение: " + SettlementRelation.Hostile;
            settlementDescriptionText.text = "Вы потерпели поражение!";

            Debug.Log("Поражение! Ваша армия отступила...");
        }

        // Обновляем интерфейс и флаг войны
        gameManager.UpdatePopulationText();
        UpdateConquerButtonInteractable();
        isWarInProgress = false;
    }

    // Игнорирование поселения
    private void IgnoreSettlement()
    {
        diplomacyPanel.SetActive(false);

        // Останавливаем корутину, связанную с currentSettlement:
        if (tradeCoroutines.ContainsKey(currentSettlement) &&
            tradeCoroutines[currentSettlement] != null)
        {
            StopCoroutine(tradeCoroutines[currentSettlement]);
            tradeCoroutines.Remove(currentSettlement); // Удаляем из словаря
        }

        // Удаляем поселение из списка активных обменов:
        if (activeTrades.Contains(currentSettlement))
        {
            activeTrades.Remove(currentSettlement);
        }

        // Удаляем поселение из списка settlements:
        settlements.Remove(currentSettlement);

        // Очищаем currentSettlement:
        currentSettlement = null;

        UpdateSettlementsListButtonVisibility();

        // Обновляем статус поселения на SettlementStatus.None
        // (чтобы это отобразилось в списке, если его открыть снова):
        if (currentSettlement != null) // Проверка на null после удаления
        {
            UpdateSettlementStatus(currentSettlement.name, SettlementStatus.None);
        }

        // Обновляем список поселений в UI:
        //OpenSettlementsListPanel();

        // Обновляем список поселений в UI, только если список не пуст:
        if (settlements.Count > 0)
        {
            OpenSettlementsListPanel();
        }
        else
        {
            settlementsListPanel.SetActive(false); // Скрываем панель, если список пуст
        }
    }

    // Открытие панели списка поселений
    public void OpenSettlementsListPanel()
    {
        settlementsListPanel.SetActive(true);

        // Очистка предыдущего списка
        foreach (Transform child in settlementsListContent.transform)
        {
            Destroy(child.gameObject);
        }

        // Заполнение списка найденными поселениями
        foreach (Settlement settlement in settlements)
        {
            GameObject listItem = Instantiate(settlementListItemPrefab, settlementsListContent);

            // Находим компонент Text внутри prefab'а
            Text listItemText = listItem.GetComponentInChildren<Text>();
            if (listItemText == null)
            {
                Debug.LogError("Ошибка: компонент Text не найден в settlementListItemPrefab.");
                continue; // Переходим к следующей итерации цикла
            }

            // Формируем текст для элемента списка
            string settlementInfo = $"{settlement.name} ({settlement.population} жителей)\n" +
                                   $"Отношение: {GetRelationText(settlement.relation)}, Статус: {GetStatusText(settlement.status)}"; // Используем функции перевода

            // Устанавливаем текст для элемента списка
            listItemText.text = settlementInfo;

            // Добавляем обработчик нажатия на элемент списка
            Button listItemButton = listItem.GetComponent<Button>();
            if (listItemButton == null)
            {
                Debug.LogError("Ошибка: компонент Button не найден в settlementListItemPrefab.");
                continue; // Переходим к следующей итерации цикла
            }

            // Используем лямбда-выражение для передачи settlement в OpenDiplomacyPanel
            listItemButton.onClick.AddListener(() =>
            {
                OpenDiplomacyPanel(settlement);
                settlementsListPanel.SetActive(false);
            });
        }
    }

    public void CloseList()
    {
        settlementsListPanel.SetActive(false);
    }

    // Game Over
    private void GameOver(string message)
    {
        gameOverPanel.SetActive(true);
        gameOverText.text = message;
        diplomacyButton.interactable = false;
    }

    // Функция для обновления статуса поселения в списке settlements
    private void UpdateSettlementStatus(string settlementName, SettlementStatus newStatus)
    {
        // Создаем копию списка settlements
        List<Settlement> settlementsCopy = new List<Settlement>(settlements);

        // Находим индекс поселения в списке settlementsCopy
        int index = settlementsCopy.FindIndex(s => s.name == settlementName);

        // Если поселение найдено, обновляем его статус в settlementsCopy
        if (index != -1)
        {
            settlementsCopy[index].status = newStatus;
        }

        // Заменяем исходный список settlements на измененную копию
        settlements = settlementsCopy;
    }

    public void GoToMainMenu()
    {
        SceneManager.LoadScene("SampleScene");
    }
}

найди баги в этом коде моей игры на двжике unity и предложи методы их решения