using System;

using System.Collections.Generic;

using System.Drawing;

public class Program

{

    public static void Main()

    {

        RectGroup rNew = new RectGroup();

        rNew.Location = new Point(10,80);

        rNew.Size = new Size(40, 15);

        rNew.Text = "New";

        rNew.CssClass = "State EnabledState";

        RectGroup rWithdrawn = new RectGroup();

        rWithdrawn.Location = new Point(10,115);

        rWithdrawn.Size = new Size(40, 15);

        rWithdrawn.Text = "Withdrawn";

        rWithdrawn.CssClass = "State EnabledState";

        RectGroup rAccepted = new RectGroup();

        rAccepted.Location = new Point(80,45);

        rAccepted.Size = new Size(40, 15);

        rAccepted.Text = "Accepted";

        rAccepted.CssClass = "State EnabledState";

        RectGroup rClosed = new RectGroup();

        rClosed.Location = new Point(150,45);

        rClosed.Size = new Size(40, 15);

        rClosed.Text = "Closed";

        rClosed.CssClass = "State EnabledState";

        RectGroup rReopened = new RectGroup();

        rReopened.Location = new Point(200,150);

        rReopened.Size = new Size(40, 15);

        rReopened.Text = "Reopened";

        rReopened.CssClass = "State EnabledState";

        RectGroup rRejected = new RectGroup();

        rRejected.Location = new Point(64,115); // was 80,115

        rRejected.Size = new Size(40, 15);

        rRejected.Text = "Rejected";

        rRejected.CssClass = "State EnabledState";

        RectGroup rScheduled = new RectGroup();

        rScheduled.Location = new Point(150,80);

        rScheduled.Size = new Size(40, 15);

        rScheduled.Text = "Scheduled";

        rScheduled.CssClass = "State EnabledState";

​

        //Arrow a1 = Arrow.SimpleArrow(r1.EastAnchor, r2.NorthAnchor);

        List<Arrow> arrows = new List<Arrow>();

        // New <==> Withdrawn

        arrows.Add(Arrow.SimpleArrow(rNew.Anchors["B2"], rWithdrawn.Anchors["T2"])); 

        arrows.Add(Arrow.SimpleArrow(rWithdrawn.Anchors["T4"], rNew.Anchors["B4"]));

        // Accepted => Closed (TODO)

        //arrows.Add(Arrow.ArrowWithMiddleElbow(rAccepted.Anchors["T2"], rClosed.WestAnchor, true));

        //arrows.Add(Arrow.ArrowWithMiddleElbow(rAccepted.Anchors["T4"], rClosed.WestAnchor, false));

        // NEW => Accepted   North => West  (Elbow)

        arrows.Add(Arrow.SimpleArrow(rNew.NorthAnchor, rAccepted.WestAnchor, new Point(rNew.NorthAnchor.X, rAccepted.WestAnchor.Y)));

        // NEW => Rejected   R3 => T2   (Elbow)

        arrows.Add(Arrow.ArrowWithMiddleElbow(rNew.R2, rRejected.T2));

        // Accepted => Closed     East => West   (Straight?)

        arrows.Add(Arrow.SimpleArrow(rAccepted.EastAnchor, rClosed.WestAnchor));

        //   Accepted => Scheduled    B4 => West   Elbow

        arrows.Add(Arrow.SimpleArrow(rAccepted.B4, rScheduled.WestAnchor, new Point(rAccepted.B4.X, rScheduled.WestAnchor.Y)));

        //   Accepted => Rejected     B2 => T4    Straight

        arrows.Add(Arrow.SimpleArrow(rAccepted.B2, rRejected.T4));

        //   Accepted => Reopened     North => East (Triple elbow)

        arrows.Add(Arrow.SimpleArrow(rAccepted.NorthAnchor, rReopened.EastAnchor, new Point(rAccepted.NorthAnchor.X, rAccepted.NorthAnchor.Y - 10), new Point(rReopened.EastAnchor.X + 10, rAccepted.NorthAnchor.Y - 10), new Point(rReopened.EastAnchor.X + 10, rReopened.EastAnchor.Y)));

        //   Closed => REopened       R1 => T5   Elbow

        arrows.Add(Arrow.ArrowWithMiddleElbow(rClosed.R1, rReopened.T5));

        //   Scheduled => Reopened    R1 => T2    Elbow

        arrows.Add(Arrow.ArrowWithMiddleElbow(rScheduled.R1, rReopened.T2));

        //   Scheduled => Closed      North => South (striaght)

        arrows.Add(Arrow.SimpleArrow(rScheduled.NorthAnchor, rClosed.SouthAnchor));

        //   Scheudled => Rejected    South => East (elbow)

        arrows.Add(Arrow.SimpleArrow(rScheduled.SouthAnchor, rRejected.EastAnchor, new Point(rScheduled.SouthAnchor.X, rRejected.EastAnchor.Y)));

        //   Rejected => Reopened    B4 => L1  Elbow

           arrows.Add(Arrow.SimpleArrow(rRejected.B4, rReopened.L1, new Point(rRejected.B4.X, rReopened.L1.Y)));

        //   Reopened => Rejected   L3 => B2   Elbow

        arrows.Add(Arrow.SimpleArrow(rReopened.L3, rRejected.B2, new Point(rRejected.B2.X, rReopened.L3.Y)));

        //   Reopened => Closed     T4 => R3 Elbow

        arrows.Add(Arrow.ArrowWithMiddleElbow(rReopened.T4, rClosed.R3));

        //   Reopened => Scheduled    T1  => R3   Elbow

        arrows.Add(Arrow.ArrowWithMiddleElbow(rReopened.T1, rScheduled.R3));

        //Arrow a2 = Arrow.ArrowWithMiddleElbow(rNew.SouthAnchor, rWithdrawn.WestAnchor, false); // To North anchor should prefer upper elbow I think...

        Console.WriteLine(rNew.ToSvg());

        Console.WriteLine(rWithdrawn.ToSvg());

        Console.WriteLine(rAccepted.ToSvg());

        Console.WriteLine(rClosed.ToSvg());

        Console.WriteLine(rReopened.ToSvg());

        Console.WriteLine(rRejected.ToSvg());

        Console.WriteLine(rScheduled.ToSvg());

        foreach(var a in arrows)

        {

            Console.WriteLine(a.ToSvg());

        }

    }

}

​

​

​

class RectGroup

{

    public Size Size { get; set; }

    public Point Location { get; set; } // Top Left Point

    public string Text { get; set; }

    private Point TextLocation

    {

        get {

            return new Point(3, 9);

        }

    }

    public string CssClass { get; set; }

    public string Id { get; set; }

    public string ToSvg() {

        string result = $@"<g transform='translate({Location.X},{Location.Y})'><rect class='{CssClass}' id='{Id}' width='{Size.Width}' height='{Size.Height}'/>" +

                        $@"<text x='{TextLocation.X}' y='{TextLocation.Y}' font-family='Verdana' font-size='6' fill='black'>{Text}</text></g>";

        // Debug code for anchor positions

        if(DebugMode) {

            List<Color> cols = new List<Color> { Color.Black } ; // Color.Red, Color.Green, Color.Blue, Color.Pink, Color.Black };

            int i = 0;

            foreach(var x in Anchors)

            {

                result += $"<circle cx='{x.Value.Location.X}' cy='{x.Value.Location.Y}' r='0.2' stroke='{cols[i].Name}' fill='{cols[i].Name}' />";

                i++; if(i >= cols.Count) i = 0;

            }

        }

        return result + "";

    }

    public bool DebugMode { get; } = false;

    public Anchor NorthAnchor { 

        get { return Anchor.TopLineAnchor(new Point(MidWidth, Top-5)); }

    }

    public Anchor SouthAnchor { 

        get { return Anchor.BottomLineAnchor(new Point(MidWidth, Bottom+5)); }

    }

    public Anchor WestAnchor { 

        get { return Anchor.LeftLineAnchor(new Point(Left-5, MidHeight)); }

    }

    public Anchor EastAnchor { 

        get { return Anchor.RightLineAnchor(new Point(Right+5, MidHeight)); }

    }

    private double QuarterWidth => Size.Width / 4;

    private double QuarterHeight => Size.Height / 4;

    public Dictionary<string, Anchor> Anchors { 

        get {

            Dictionary<string, Anchor> list = new Dictionary<string, Anchor>();

            list.Add("T1", Anchor.TopLineAnchor(Location.X + Size.Width*0.15, Top-5));

            list.Add("T2", Anchor.TopLineAnchor(Location.X + Size.Width*0.30, Top-5));

            list.Add("T3", NorthAnchor);

            list.Add("T4", Anchor.TopLineAnchor(Location.X + Size.Width*0.70, Top-5));

            list.Add("T5", Anchor.TopLineAnchor(Location.X + Size.Width*0.85, Top-5));

            list.Add("B1", Anchor.BottomLineAnchor(Location.X + Size.Width*0.15, Bottom+5));

            list.Add("B2", Anchor.BottomLineAnchor(Location.X + Size.Width*0.30, Bottom+5));

            list.Add("B3", SouthAnchor);

            list.Add("B4", Anchor.BottomLineAnchor(Location.X + Size.Width*0.70, Bottom+5));

            list.Add("B5", Anchor.BottomLineAnchor(Location.X + Size.Width*0.85, Bottom+5));

            list.Add("L1", Anchor.LeftLineAnchor(Left - 5, Location.Y + Size.Height * 0.25));

            list.Add("L2", WestAnchor);

            list.Add("L3", Anchor.LeftLineAnchor(Left - 5, Location.Y + Size.Height * 0.75));

            list.Add("R1", Anchor.LeftLineAnchor(Right + 5, Location.Y + Size.Height * 0.25));

            list.Add("R2", EastAnchor);

            list.Add("R3", Anchor.LeftLineAnchor(Right + 5, Location.Y + Size.Height * 0.75));

            return list;

        }

    }

    public Anchor T1 => Anchors["T1"];

    public Anchor T2 => Anchors["T2"];

    public Anchor T3 => Anchors["T3"];

    public Anchor T4 => Anchors["T4"];

    public Anchor T5 => Anchors["T5"];

    public Anchor B1 => Anchors["B1"];

    public Anchor B2 => Anchors["B2"];

    public Anchor B3 => Anchors["B3"];

    public Anchor B4 => Anchors["B4"];

    public Anchor B5 => Anchors["B5"];

    public Anchor L1 => Anchors["L1"];

    public Anchor L2 => Anchors["L2"];

    public Anchor L3 => Anchors["L3"];

    public Anchor R1 => Anchors["R1"];

    public Anchor R2 => Anchors["R2"];

    public Anchor R3 => Anchors["R3"];

    private double Left { get { return Location.X; } }

    private double Right { get { return Location.X + Size.Width; } }

    private double Top { get { return Location.Y; } }

    private double Bottom { get { return Location.Y + Size.Height; } }

    private double MidWidth { get { return Location.X + Size.Width / 2; } }

    private double MidHeight { get { return Location.Y + Size.Height / 2; } }

}

​

class Anchor

{

    public static Anchor TopLineAnchor(double x, double y)

    {

        return TopLineAnchor(new Point(x, y));

    }

    public static Anchor TopLineAnchor(Point location)

    {

        return new Anchor { Location = location, IsTopLine = true };

    }

    public static Anchor BottomLineAnchor(double x, double y)

    {

        return BottomLineAnchor(new Point(x, y));

    }

    public static Anchor BottomLineAnchor(Point location)

    {

        return new Anchor { Location = location, IsBottomLine = true };

    }

    public static Anchor LeftLineAnchor(Point location)

    {

        return new Anchor { Location = location, IsLeftLine = true };

    }

    public static Anchor LeftLineAnchor(double x, double y)

    {

        return LeftLineAnchor(new Point(x, y));

    }

    public static Anchor RightLineAnchor(Point location)

    {

        return new Anchor { Location = location, IsRightLine = true };

    }

    public static Anchor RightLineAnchor(double x, double y)

    {

        return RightLineAnchor(new Point(x, y));

    }

    public Point Location { get; set; }

    public bool IsTopLine { get; set; }

    public bool IsBottomLine { get; set; }

    public bool IsLeftLine { get; set; }

    public bool IsRightLine { get; set; }

    public double X => Location.X;

    public double Y => Location.Y;

}

​

class Arrow

{

    //public static Arrow SimpleArrow(Anchor Start, Anchor End) 

    //{

    //  return new Arrow { OrderedPoints = new List<Point> { Start.Location, End.Location } };

    //}

    public static Arrow ArrowWithMiddleElbow(Anchor Start, Anchor End, bool preferLineAbove = true) 

    {

        double xmax = Start.Location.X;

        double xmin = End.Location.X;

        if(End.Location.X > xmax) { xmax = End.Location.X; xmin = Start.Location.X; }

        double ymax = Start.Location.Y;

        double ymin = End.Location.Y;

        if(End.Location.Y > ymax) { ymax = End.Location.Y; ymin = Start.Location.Y; }

        Point midpoint;

        if(preferLineAbove) midpoint = new Point(xmax, ymin);

        else midpoint = new Point(xmin, ymax);

        return new Arrow { OrderedPoints = new List<Point> { Start.Location, midpoint, End.Location } };

    }

    public static Arrow SimpleArrow(Anchor Start, Anchor End, params Point[] elbows) 

    {

        List<Point> op = new List<Point>();

        op.Add(Start.Location);

        if(elbows != null) op.AddRange(elbows);

        op.Add(End.Location);

        return new Arrow { OrderedPoints = op };

    }

    public List<Point> OrderedPoints { get; set; }

    public string Label { get; set; }

    private Point TextLocation

    {

        get {

            // No idea yet

            return new Point();

        }

    }

    public string ToSvg() {

        string pointList = "";

        foreach(var p in OrderedPoints)

        {

            pointList += p.X + "," + p.Y + " ";

        }

        return $@"<path d='M{pointList}' marker-end='url(#pointer)' marker-start='' />";

    }

}

​

class Point

{

    public Point() {}

    public Point(double x, double y) { X = x; Y = y; }

    public double X { get; set; }

    public double Y { get; set; }

}

class Size

{

    public Size() {}

    public Size(double width, double height) { Width = width; Height = height; }

    public double Width { get; set; }

    public double Height { get; set; }

}