using System;
using System.Collections.Generic;
using System.Linq;
using Data;

namespace Managers
{
    public class AffiliationManager:Utils.Singleton<AffiliationManager>
    {
        //定义名，阵营定义
        private readonly Dictionary<string, AffiliationDef> _affiliations = new();
        
        public void Init()
        {
            var affiliationList = Managers.DefineManager.Instance.QueryDefinesByType<AffiliationDef>();
            if (affiliationList == null ||affiliationList.Length==0)
                return;
            foreach (var affiliation in affiliationList)
            {
                _affiliations.Add(affiliation.defName, affiliation);
            }
            ValidateAndFixRelationships();
        }

        public string GetAffiliationName(string defName)
        {
            return _affiliations[defName].defName;
        }

        public Relation GetRelation(string factionName1, string factionName2)
        {
            // 如果查询的是同一个派系，默认是友好关系
            if (factionName1 == factionName2)
            {
                return Relation.Friendly;
            }

            // 尝试获取两个派系的定义
            if (!_affiliations.TryGetValue(factionName1, out var faction1) ||
                !_affiliations.TryGetValue(factionName2, out _))
            {
                if (faction1 != null) return faction1.defaultRelation;
                return Relation.Neutral;
            }

            // 检查faction1是否明确将faction2列为敌对
            if (faction1.hostileFactions != null && faction1.hostileFactions.Contains(factionName2))
            {
                return Relation.Hostile;
            }

            // 检查faction1是否明确将faction2列为友好
            if (faction1.friendlyFactions != null && faction1.friendlyFactions.Contains(factionName2))
            {
                return Relation.Friendly;
            }

            // 检查faction1是否明确将faction2列为中立
            if (faction1.neutralFactions != null && faction1.neutralFactions.Contains(factionName2))
            {
                return Relation.Neutral;
            }

            // 如果faction1没有明确设置与faction2的关系，则使用faction1的默认关系
            return faction1.defaultRelation;
        }
        
        /// <summary>
        /// 设置两个阵营之间的关系
        /// </summary>
        /// <param name="factionName1">第一个阵营名称</param>
        /// <param name="factionName2">第二个阵营名称</param>
        /// <param name="relation">要设置的关系</param>
        public void SetRelation(string factionName1, string factionName2, Relation relation)
        {
            // 不能设置自己与自己的关系
            if (factionName1 == factionName2)
            {
                throw new ArgumentException("Cannot set relation between the same faction");
            }

            // 确保两个阵营都存在
            if (!_affiliations.TryGetValue(factionName1, out var faction1) ||
                !_affiliations.TryGetValue(factionName2, out _))
            {
                throw new ArgumentException("One or both factions do not exist");
            }

            // 确保关系列表已初始化
            faction1.hostileFactions ??= new List<string>();
            faction1.friendlyFactions ??= new List<string>();
            faction1.neutralFactions ??= new List<string>();

            // 先移除所有现有关系
            faction1.hostileFactions.Remove(factionName2);
            faction1.friendlyFactions.Remove(factionName2);
            faction1.neutralFactions.Remove(factionName2);

            // 添加新关系
            switch (relation)
            {
                case Relation.Hostile:
                    faction1.hostileFactions.Add(factionName2);
                    break;
                case Relation.Friendly:
                    faction1.friendlyFactions.Add(factionName2);
                    break;
                case Relation.Neutral:
                    faction1.neutralFactions.Add(factionName2);
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(relation), relation, null);
            }
        }
        
        /// <summary>
        /// 检查并修复派系关系，确保没有冲突（按友好 > 敌对 > 中立 的优先级）
        /// </summary>
        private void ValidateAndFixRelationships()
        {
            foreach (var faction in _affiliations.Values)
            {
                // 确保所有关系列表已初始化
                faction.hostileFactions ??= new List<string>();
                faction.friendlyFactions ??= new List<string>();
                faction.neutralFactions ??= new List<string>();

                // 检查所有敌对派系
                foreach (var hostileFaction in faction.hostileFactions.ToList())
                {
                    // 如果敌对派系同时存在于友好列表中，移除敌对关系（友好优先）
                    if (faction.friendlyFactions.Contains(hostileFaction))
                    {
                        faction.hostileFactions.Remove(hostileFaction);
                        continue;
                    }

                    // 如果敌对派系同时存在于中立列表中，移除中立关系（敌对优先）
                    if (faction.neutralFactions.Contains(hostileFaction))
                    {
                        faction.neutralFactions.Remove(hostileFaction);
                    }
                }

                // 检查所有中立派系
                foreach (var neutralFaction in faction.neutralFactions.ToList())
                {
                    // 如果中立派系同时存在于友好列表中，移除中立关系（友好优先）
                    if (faction.friendlyFactions.Contains(neutralFaction))
                    {
                        faction.neutralFactions.Remove(neutralFaction);
                    }
                }
            }
        }
    }
}