/*
    ......... 2015 Ivan Mahonin

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

using System;
using System.Collections.Generic;
using System.Data.Linq;
using System.Drawing;
using System.IO;
using System.Globalization;

namespace Diagram {

    public class ActiveBlock {
        public Block block;
        public readonly List<ActiveLink> links = new List<ActiveLink>();
        public PointF position;

        public Font captionFont;
        public Font textFont;
        public float margin;
        public float padding;
        public Pen pen;
        public Brush brush;

        public string caption;
        public string text;
        public SizeF captionSize;
        public SizeF textSize;
        public float distance;

        public SizeF size;
        public SizeF clientSize;

        public PointF getCenter() {
            return new PointF(
                position.X + 0.5f*size.Width,
                position.Y + 0.5f*size.Height );
        }

        public void measure() {
            float width = captionFont.GetHeight() * 15f;
            caption = TextUtils.wrap(block.caption, width, captionFont);
            captionSize = TextUtils.measure(caption, captionFont);
            text = TextUtils.wrap(block.text, width, textFont);
            textSize = TextUtils.measure(text, textFont);
            if (caption != "" && text != "")
                distance = 0.3f * Math.Max(captionFont.GetHeight(), textFont.GetHeight());
            clientSize = new SizeF(
                Math.Max(captionSize.Width, textSize.Width),
                captionSize.Height + distance + textSize.Height );
            size = new SizeF(clientSize.Width + 2f*padding, clientSize.Height + 2f*padding);
        }

        public void draw(Graphics g) {
            Shapes.drawRoundRect(g, new RectangleF(position, size), 2f*padding, pen, brush);

            g.DrawString(
                caption,
                captionFont,
                Brushes.Black,
                new RectangleF(
                    position.X + 0.5f*(size.Width - captionSize.Width),
                    position.Y + padding,
                    captionSize.Width,
                    captionSize.Height ));

            g.DrawString(
                text,
                textFont,
                Brushes.Black,
                new RectangleF(
                    position.X + padding,
                    position.Y + padding + captionSize.Height + distance,
                    clientSize.Width,
                    clientSize.Height - captionSize.Height - distance ));
        }

        class LinkDesc {
            public ActiveLink link;
            public PointF src;
            public PointF dst;
        }

        class SideDesc {
            public PointF a;
            public PointF b;
            public PointF normal;
            public readonly List<LinkDesc> links = new List<LinkDesc>();

            public SideDesc(PointF a, PointF b) {
                this.a = a;
                this.b = b;
                float l = Geometry.lineLength(a, b);
                normal = new PointF((b.Y - a.Y)/l, (a.X - b.X)/l);
            }
        }

        public void placeLinks() {
            PointF lt = position;
            PointF rb = new PointF(lt.X + size.Width, lt.Y + size.Height);
            PointF lb = new PointF(lt.X, rb.Y);
            PointF rt = new PointF(rb.X, lt.Y);
            PointF center = getCenter();

            List<SideDesc> sides = new List<SideDesc>() {
                new SideDesc(lt, rt),
                new SideDesc(rt, rb),
                new SideDesc(rb, lb),
                new SideDesc(lb, lt) };

            foreach(ActiveLink link in links) {
                link.visible = false;
                LinkDesc linkDesc = new LinkDesc();
                linkDesc.link = link;
                if (link.src == this) {
                    linkDesc.src = center;
                    linkDesc.dst = link.dst.getCenter();
                } else {
                    linkDesc.src = link.src.getCenter();
                    linkDesc.dst = center;
                }
                foreach(SideDesc side in sides) {
                    PointF p;
                    if (Geometry.findIntersection(side.a, side.b, linkDesc.src, linkDesc.dst, out p)) {
                        link.visible = true;
                        linkDesc.src = p;
                        side.links.Add(linkDesc);
                        break;
                    }
                }
            }

            foreach(SideDesc side in sides) {
                side.links.Sort(delegate(LinkDesc a, LinkDesc b) {
                    return Geometry.comparePointsAtLine(a.src, b.src, side.a, side.b); });
                for(int i = 0; i < side.links.Count; ++i) {
                    ActiveLink link = side.links[i].link;
                    PointF p = Geometry.pointAtLine(side.a, side.b, i, side.links.Count, padding);
                    if (link.src == this) {
                        link.srcBase = p;
                        link.srcTangent = side.normal;
                        link.pen = pen;
                    } else {
                        link.dstBase = p;
                        link.dstTangent = new PointF(-side.normal.X, -side.normal.Y);
                    }
                }
            }
        }
    }

    public class ActiveLink {
        public Link link;
        public ActiveBlock src;
        public ActiveBlock dst;

        public SizeF arrowSize;
        public Pen pen;

        public bool visible;
        public PointF srcBase;
        public PointF srcTangent;
        public PointF dstBase;
        public PointF dstTangent;

        public PointF[] bezier;
        public PointF[] arrow;

        public static readonly PointF[] arrowTemplate = new PointF[] {
            new PointF(0f, 0f),
            new PointF(1f, 1f),
            new PointF(0f, 0.75f) };

        public static readonly float arrowOffset = 0.75f;

        public static PointF[] makeArrow(PointF point, PointF tangent, SizeF size) {
            PointF[] arrow = new PointF[2*arrowTemplate.Length];
            PointF tx = new PointF( -0.5f*tangent.Y*size.Width, 0.5f*tangent.X*size.Width  );
            PointF ty = new PointF( -tangent.X*size.Height, -tangent.Y*size.Height );
            for(int i = 0; i < arrowTemplate.Length; ++i) {
                arrow[i] = new PointF(
                    point.X + tx.X*arrowTemplate[i].X + ty.X*arrowTemplate[i].Y,
                    point.Y + tx.Y*arrowTemplate[i].X + ty.Y*arrowTemplate[i].Y );
                arrow[2*arrowTemplate.Length - i - 1] = new PointF(
                    point.X - tx.X*arrowTemplate[i].X + ty.X*arrowTemplate[i].Y,
                    point.Y - tx.Y*arrowTemplate[i].X + ty.Y*arrowTemplate[i].Y );
            }
            return arrow;
        }

        public void place() {
            if (!visible) return;

            float dx = 0.5f*Math.Abs(dstBase.X - srcBase.X);
            float dy = 0.5f*Math.Abs(dstBase.Y - srcBase.Y);
            float l = (float)Math.Sqrt(dx*dx + dy*dy);
            if (l < Geometry.precision) { visible = false; return; }
            dx = Math.Max(dx, 0.25f*l);
            dy = Math.Max(dy, 0.25f*l);

            float sl = l;
            if (Math.Abs(srcTangent.X) > Geometry.precision)
                sl = Math.Min(sl, dx/Math.Abs(srcTangent.X));
            if (Math.Abs(srcTangent.Y) > Geometry.precision)
                sl = Math.Min(sl, dy/Math.Abs(srcTangent.Y));
            PointF st = new PointF(srcTangent.X*sl, srcTangent.Y*sl);

            float dl = l;
            if (Math.Abs(dstTangent.X) > Geometry.precision)
                dl = Math.Min(dl, dx/Math.Abs(dstTangent.X));
            if (Math.Abs(dstTangent.Y) > Geometry.precision)
                dl = Math.Min(dl, dy/Math.Abs(dstTangent.Y));
            PointF dt = new PointF(dstTangent.X*sl, dstTangent.Y*sl);

            bezier = new PointF[] {
                srcBase,
                new PointF(srcBase.X + st.X, srcBase.Y + st.Y),
                new PointF(dstBase.X - dt.X, dstBase.Y - dt.Y),
                new PointF(dstBase.X - dstTangent.X*(arrowOffset*arrowSize.Height + 0.5f*pen.Width),
                           dstBase.Y - dstTangent.Y*(arrowOffset*arrowSize.Height + 0.5f*pen.Width))
            };

            arrow = makeArrow(
                new PointF(dstBase.X - 0.5f*dstTangent.X*pen.Width,
                           dstBase.Y - 0.5f*dstTangent.Y*pen.Width),
                dstTangent,
                arrowSize );
        }

        public void draw(Graphics g) {
            if (!visible) return;
            g.DrawBeziers(pen, bezier);
            g.FillPolygon(new SolidBrush(pen.Color), arrow);
            //g.DrawPolygon(pen, arrow);
        }
    }

    public class ActiveDiagram {
        public Diagram diagram;

        public readonly Dictionary<string, PointF> positions = new Dictionary<string, PointF>();

        public Font captionFont;
        public Font textFont;
        public float margin;
        public float padding;
        public SizeF arrowSize;
        public Pen pen;
        public Brush brush;

        public readonly Dictionary<string, ActiveBlock> blocks = new Dictionary<string, ActiveBlock>();
        public readonly Dictionary<string, ActiveLink> links = new Dictionary<string, ActiveLink>();

        public RectangleF bounds;

        public void savePositions(string filename) {
            remeberPositions();
            CultureInfo ci = new CultureInfo("en-US");
            List<string> lines = new List<string>();
            foreach(KeyValuePair<string, PointF> pair in positions) {
                lines.Add(pair.Key);
                lines.Add(pair.Value.X.ToString(ci));
                lines.Add(pair.Value.Y.ToString(ci));
            }
            File.Create(filename).Close();
            File.WriteAllLines(filename, lines);
        }

        public void loadPositions(string filename) {
            CultureInfo ci = new CultureInfo("en-US");
            string[] lines = File.ReadAllLines(filename);
            for(int i = 0; i < lines.Length - 2; i += 3) {
                string k = lines[i];
                PointF p = new PointF(
                    float.Parse(lines[i+1], ci),
                    float.Parse(lines[i+2], ci) );
                if (positions.ContainsKey(k))
                    positions[k] = p;
                else
                    positions.Add(k, p);
            }
            restorePositions();
        }

        public void remeberPositions() {
            foreach(KeyValuePair<string, ActiveBlock> pair in blocks)
                if (positions.ContainsKey(pair.Key))
                    positions[pair.Key] = pair.Value.position;
                else
                    positions.Add(pair.Key, pair.Value.position);
        }

        public void restorePositions() {
            foreach(KeyValuePair<string, ActiveBlock> pair in blocks)
                if (positions.ContainsKey(pair.Key))
                    pair.Value.position = positions[pair.Key];
            placeLinks();
        }

        // insert/remove blocks and links calculate sizes
        public void reloadDiagram() {
            remeberPositions();

            bool retry;

            // blocks
            foreach(KeyValuePair<string, ActiveBlock> pair in blocks)
                pair.Value.block = null;
            foreach(KeyValuePair<string, Block> pair in diagram.blocks) {
                if (!blocks.ContainsKey(pair.Key))
                    blocks.Add(pair.Key, new ActiveBlock());
                ActiveBlock b = blocks[pair.Key];
                b.block = pair.Value;
                b.links.Clear();
                b.captionFont = captionFont;
                b.textFont = textFont;
                b.margin = margin;
                b.padding = padding;
                b.pen = new Pen(new SolidBrush(b.block.color), pen.Width);
                b.brush = brush;
            }
            retry = true;
            while(retry) {
                retry = false;
                foreach(KeyValuePair<string, ActiveBlock> pair in blocks)
                    if (pair.Value.block == null)
                        { blocks.Remove(pair.Key); retry = true; break; }
            }

            // links
            foreach(KeyValuePair<string, ActiveLink> pair in links)
                pair.Value.link = null;
            foreach(KeyValuePair<string, Link> pair in diagram.links) {
                if ( blocks.ContainsKey(pair.Value.srcId)
                  && blocks.ContainsKey(pair.Value.dstId) )
                {
                    if (!links.ContainsKey(pair.Key))
                        links.Add(pair.Key, new ActiveLink());
                    ActiveLink l = links[pair.Key];
                    l.link = pair.Value;
                    l.src = blocks[l.link.srcId];
                    l.src.links.Add(l);
                    l.dst = blocks[l.link.dstId];
                    l.dst.links.Add(l);
                    l.arrowSize = arrowSize;
                    l.pen = pen;
                }
            }
            retry = true;
            while(retry) {
                retry = false;
                foreach(KeyValuePair<string, ActiveLink> pair in links)
                    if (pair.Value.link == null)
                        { links.Remove(pair.Key); retry = true; break; }
            }

            measureBlocks();
        }

        public void measureBlocks() {
            foreach(KeyValuePair<string, ActiveBlock> pair in blocks)
                pair.Value.measure();
            placeLinks();
        }

        public void placeLinks() {
            foreach(KeyValuePair<string, ActiveBlock> pair in blocks)
                pair.Value.placeLinks();
            foreach(KeyValuePair<string, ActiveLink> pair in links)
                pair.Value.place();
            recalcBounds();
        }

        public void recalcBounds() {
            if (blocks.Count == 0) { bounds = new RectangleF(); return; }
            float minx = float.PositiveInfinity;
            float miny = float.PositiveInfinity;
            float maxx = float.NegativeInfinity;
            float maxy = float.NegativeInfinity;
            foreach(KeyValuePair<string, ActiveBlock> pair in blocks) {
                minx = Math.Min(minx, pair.Value.position.X - pair.Value.margin);
                miny = Math.Min(miny, pair.Value.position.Y - pair.Value.margin);
                maxx = Math.Max(maxx, pair.Value.position.X + pair.Value.size.Width + pair.Value.margin);
                maxy = Math.Max(maxy, pair.Value.position.Y + pair.Value.size.Height + pair.Value.margin);
            }
            bounds = new RectangleF(minx, miny, maxx - minx, maxy - miny);
        }

        public void draw(Graphics g) {
            foreach(KeyValuePair<string, ActiveLink> pair in links)
                pair.Value.draw(g);
            foreach(KeyValuePair<string, ActiveBlock> pair in blocks)
                pair.Value.draw(g);
        }
    }
}