using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Shapes;

namespace PamhagenSysCtrl.Helpers.Pipeline {
    public class Graph {

        public HashSet<INode> Nodes = [];
        public HashSet<IEdge> Edges = [];

        public Graph() {

        }

        public Pipe CreatePipe(INode start, INode end, bool verticalFirst = false, string? label = null, double? labelOffsetX = null) {
            Nodes.Add(start);
            Nodes.Add(end);
            var p = new Pipe(start, end, label, verticalFirst, default, labelOffsetX);
            start.Outputs.Add(p);
            end.Inputs.Add(p);
            Edges.Add(p);
            return p;
        }

        public Pipe CreateTwoWayPipe(INode n1, INode n2, bool verticalFirst = false) {
            Nodes.Add(n1);
            Nodes.Add(n2);
            var p = new Pipe(n1, n2, default, verticalFirst, twoWay: true);
            n1.Inputs.Add(p);
            n1.Outputs.Add(p);
            n2.Inputs.Add(p);
            n2.Outputs.Add(p);
            Edges.Add(p);
            return p;
        }

        public Inlet CreateInlet(INode start, ISink end, bool sideways = false) {
            Nodes.Add(start);
            Nodes.Add(end);
            var p = new Inlet(start, end, sideways);
            start.Outputs.Add(p);
            end.Inputs.Add(p);
            Edges.Add(p);
            return p;
        }

        public Outlet CreateOutlet(ISource start, INode end) {
            Nodes.Add(start);
            Nodes.Add(end);
            var p = new Outlet(start, end);
            start.Outputs.Add(p);
            end.Inputs.Add(p);
            Edges.Add(p);
            return p;
        }

        public Path? GetPath(IEnumerable<INode> points, Func<INode, bool>? valid = null, Func<Path, int>? cost = null) {
            if (points.Count() < 2) return null;
            var start = points.First();
            List<Path> paths = [new(start, [])];
            foreach (var end in points.Skip(1)) {
                if (valid != null && start != points.First() && !valid(start))
                    return null;

                var newPaths = new List<Path>();
                foreach (var path in paths) {
                    foreach (var subPath in GetPaths(start, end, visited: [.. path.Hops.Select(h => h.Node)], valid)) {
                        newPaths.Add(new(path.Start, [.. path.Hops, .. subPath.Hops]));
                    }
                }
                if (newPaths.Count == 0)
                    return null;

                paths = newPaths;
                start = end;
            }
            if (paths.Count == 0) {
                return null;
            } else {
                cost ??= p => 0;
                return paths.OrderBy(cost).First();
            }
        }

        public IEnumerable<Path> GetPaths(INode start, INode end, HashSet<INode>? visited = null, Func<INode, bool>? valid = null) {
            if (!Nodes.Contains(start) || !Nodes.Contains(end)) throw new ArgumentException("Start/end node not contained in graph");
            valid ??= a => true;
            visited = [.. visited ?? [], start];
            List<(IEdge, INode)> hops = [];
            foreach (var o in start.Outputs) {
                var e = o.IsTwoWay && o.End == start ? o.Start : o.End;
                if (e == end) {
                    yield return new(start, [(o, e)]);
                    continue;
                } else if (!valid(e) || visited.Contains(e)) {
                    continue;
                }

                foreach (var p in GetPaths(e, end, visited, valid)) {
                    yield return new(start, [(o, e), .. p.Hops]);
                }
            }
        }

        public void Draw(Canvas canvas) {
            canvas.Children.Add(new Rectangle() {
                Fill = Brushes.White,
                Width = 5000,
                Height = 5000,
            });
            foreach (var e in Edges) {
                e.Draw(canvas);
            }
            foreach (var n in Nodes) {
                n.Draw(canvas);
            }
        }

        public ISet<INode> GetHover(double x, double y) {
            return Nodes.Where(n => n.IsInside(x, y)).ToHashSet();
        }

        public void Update(ISet<INode> hovering, bool isPressed) {
            foreach (var e in Edges) {
                e.Update();
            }
            foreach (var n in Nodes) {
                n.Update(hovering.Contains(n), isPressed);
            }
        }
    }
}