using System.Collections.Generic;

namespace SolutionCleanupTool.Models
{
    /// <summary>
    /// Represents a dependency graph of projects within a solution
    /// </summary>
    public class DependencyGraph
    {
        public Dictionary<string, List<string>> Dependencies { get; set; } = new Dictionary<string, List<string>>();
        public List<ProjectReference> Nodes { get; set; } = new List<ProjectReference>();
        
        /// <summary>
        /// Adds a dependency relationship between two projects
        /// </summary>
        public void AddDependency(string fromProject, string toProject)
        {
            if (!Dependencies.ContainsKey(fromProject))
            {
                Dependencies[fromProject] = new List<string>();
            }
            
            if (!Dependencies[fromProject].Contains(toProject))
            {
                Dependencies[fromProject].Add(toProject);
            }
        }
        
        /// <summary>
        /// Checks if the dependency graph has circular references
        /// </summary>
        public bool HasCircularReferences()
        {
            var visited = new HashSet<string>();
            var recursionStack = new HashSet<string>();
            
            foreach (var node in Dependencies.Keys)
            {
                if (HasCircularReferencesUtil(node, visited, recursionStack))
                {
                    return true;
                }
            }
            
            return false;
        }
        
        private bool HasCircularReferencesUtil(string node, HashSet<string> visited, HashSet<string> recursionStack)
        {
            if (recursionStack.Contains(node))
            {
                return true;
            }
            
            if (visited.Contains(node))
            {
                return false;
            }
            
            visited.Add(node);
            recursionStack.Add(node);
            
            if (Dependencies.ContainsKey(node))
            {
                foreach (var neighbor in Dependencies[node])
                {
                    if (HasCircularReferencesUtil(neighbor, visited, recursionStack))
                    {
                        return true;
                    }
                }
            }
            
            recursionStack.Remove(node);
            return false;
        }
    }
}