Command.cs

using DrawPad.Kernel.Base;
using DrawPad.Kernel.Shapes;
using DrawPad.Kernel;
using System;
using System.Collections.Generic;
using System.Linq;
using Calcpad.Core;
using System.Windows.Forms;
namespace DrawPad
{
    class Commander
    {
        internal event EventHandler OptionsChanged;
        internal delegate void Command();
        private readonly Viewer View;
        private readonly Model _model;
        private readonly Interaction _input;
        private readonly MathParser mp;
        private readonly Dictionary<string, Command> Commands;
        private readonly Dictionary<string, string> Aliases;
        private readonly List<string> TransparentCommands;
        private string LastCommand = string.Empty;
        private bool IsCopy = false;
        private int NumberOfCopies = 1;
        internal string[] CommandList => [.. Commands.Keys, .. Aliases.Keys];

        private readonly MathSettings _settings = new(); 
        internal Commander(Viewer View)
        {
            mp = new MathParser(_settings);
            this.View = View;
            _model = View.Model;
            _input = View.Interaction;
            _input.Evaluate = Evaluate;
            Commands = [];
            Aliases = [];
            TransparentCommands = [];
            Commands.Add("ALL", new Command(All));
            Commands.Add("DESELECT", new Command(Deselect));
            Commands.Add("PREVIOUS", new Command(View.SelectPrevious));
            Commands.Add("DELETE", new Command(Delete));
            Commands.Add("OOPS", new Command(View.Oops));
            Commands.Add("POINT", new Command(Point));
            Commands.Add("CIRCLE", new Command(Circle));
            Commands.Add("ARC", new Command(Arc));
            Commands.Add("TEXT", new Command(Text));
            Commands.Add("LINE", new Command(Line));
            Commands.Add("RECTANGLE", new Command(Rectangle));
            Commands.Add("POLYLINE", new Command(Polyline));
            Commands.Add("POLYGON", new Command(Polygon));
            Commands.Add("DIMA", new Command(DimAligned));
            Commands.Add("DIMX", new Command(DimHorizontal));
            Commands.Add("DIMY", new Command(DimVertical));
            Commands.Add("DIMS", new Command(DimSection));
            Commands.Add("BLOCK", new Command(Block));
            Commands.Add("INSERT", new Command(Insert));
            Commands.Add("MOVE", new Command(Move));
            Commands.Add("ROTATE", new Command(Rotate));
            Commands.Add("MIRROR", new Command(Mirror));
            Commands.Add("SCALE", new Command(Scale));
            Commands.Add("STRETCH", new Command(Stretch));
            Commands.Add("COPY", new Command(Copy));
            Commands.Add("ARRAY", new Command(Array));
            Commands.Add("OFFSET", new Command(Offset));
            Commands.Add("CLOSE", new Command(Close));
            Commands.Add("EXPLODE", new Command(Explode));
            Commands.Add("JOIN", new Command(Join));
            Commands.Add("BREAK", new Command(Break));
            Commands.Add("LENGTHEN", new Command(Lengthen));
            Commands.Add("VERTEXDEL", new Command(RemoveVertex));
            Commands.Add("VERTEXADD", new Command(AddVertex));
            Commands.Add("UNION", new Command(Union));
            Commands.Add("INTERSECT", new Command(Intersect));
            Commands.Add("SUBTRACT", new Command(Subtract));
            Commands.Add("SLICE", new Command(Slice));
            Commands.Add("EDIT", new Command(Edit));
            Commands.Add("DIMALIGN", new Command(AlignDimensions));
            Commands.Add("GRID", new Command(Grid));
            Commands.Add("DISTANCE", new Command(Distance));
            Commands.Add("AREA", new Command(Area));
            Commands.Add("MASSPROP", new Command(MassProp));
            Commands.Add("HEIGHT", new Command(Height));
            Commands.Add("MASS", new Command(Mass));
            Commands.Add("LAYON", new Command(LayerOn));
            Commands.Add("LAYOFF", new Command(LayerOff));
            Commands.Add("LAYLCK", new Command(LayerLock));
            Commands.Add("LAYULK", new Command(LayerUnlock));
            Commands.Add("LAYISO", new Command(LayerIsolate));
            Commands.Add("LAYUNISO", new Command(LayerUnlock));
            Commands.Add("LAYCUR", new Command(LayerCurrent));
            Commands.Add("BACK", new Command(Back));
            Commands.Add("FRONT", new Command(Front));
            Commands.Add("UNDO", new Command(Undo));
            Commands.Add("REDO", new Command(Redo));
            Commands.Add("SNAP", new Command(Snap));
            Commands.Add("ORTHO", new Command(Ortho));
            Commands.Add("OSNAP", new Command(Osnap));
            Commands.Add("ZOOMIN", new Command(ZoomIn));
            Commands.Add("ZOOMOUT", new Command(ZoomOut));
            Commands.Add("ZOOMWINDOW", new Command(ZoomWindow));
            Commands.Add("ZOOMALL", new Command(ZoomAll));
            TransparentCommands.Add("GRID");
            TransparentCommands.Add("SNAP");
            TransparentCommands.Add("ORTHO");
            TransparentCommands.Add("OSNAP");
            TransparentCommands.Add("ZOOMIN");
            TransparentCommands.Add("ZOOMOUT");
            TransparentCommands.Add("ZOOMALL");
            Aliases.Add("DEL", "DELETE");
            Aliases.Add("PO", "POINT");
            Aliases.Add("L", "LINE");
            Aliases.Add("PL", "POLYLINE");
            Aliases.Add("POL", "POLYGON");
            Aliases.Add("REC", "RECTANGLE");
            Aliases.Add("C", "CIRCLE");
            Aliases.Add("A", "ARC");
            Aliases.Add("T", "TEXT");
            Aliases.Add("DT", "TEXT");
            Aliases.Add("B", "BLOCK");
            Aliases.Add("I", "INSERT");
            Aliases.Add("M", "MOVE");
            Aliases.Add("R", "ROTATE");
            Aliases.Add("RO", "ROTATE");
            Aliases.Add("SC", "SCALE");
            Aliases.Add("MI", "MIRROR");
            Aliases.Add("S", "STRETCH");
            Aliases.Add("CO", "COPY");
            Aliases.Add("CP", "COPY");
            Aliases.Add("AR", "ARRAY");
            Aliases.Add("O", "OFFSET");
            Aliases.Add("CL", "CLOSE");
            Aliases.Add("X", "EXPLODE");
            Aliases.Add("J", "JOIN");
            Aliases.Add("BR", "BREAK");
            Aliases.Add("LEN", "LENGTHEN");
            Aliases.Add("VD", "VERTEXDEL");
            Aliases.Add("VA", "VERTEXADD");
            Aliases.Add("UN", "UNION");
            Aliases.Add("UNI", "UNION");
            Aliases.Add("IN", "INTERSECT");
            Aliases.Add("SU", "SUBTRACT");
            Aliases.Add("SL", "SLICE");
            Aliases.Add("ED", "EDIT");
            Aliases.Add("DA", "DIMALIGN");
            Aliases.Add("DI", "DISTANCE");
            Aliases.Add("MP", "MASSPROP");
            Aliases.Add("H", "HEIGHT");
            Aliases.Add("U", "UNDO");
            Aliases.Add("RE", "REDO");
            Aliases.Add("GR", "GRID");
            Aliases.Add("SN", "SNAP");
            Aliases.Add("OR", "ORTHO");
            Aliases.Add("OS", "OSNAP");
            Aliases.Add("Z", "ZOOMWINDOW");
            Aliases.Add("ZW", "ZOOMWINDOW");
            Aliases.Add("ZI", "ZOOMIN");
            Aliases.Add("ZO", "ZOOMOUT");
            Aliases.Add("ZA", "ZOOMALL");
        }

        internal void AddCommand(string name, Command method) => 
            Commands.Add(name, new Command(method));

        internal void AddAlias(string name, string alias) => 
            Aliases.Add(alias, name);

        internal void Parse(string script)
        {
            ReadOnlySpan<char> chars = [' ', '\n'];
            var tokens = script.Split(chars);
            foreach (var s in tokens)
                Run(s.ToString());
        }

        internal void Run(ReadOnlySpan<char> command)
        {
            _input.SetCommandText(string.Empty);
            string alias = command.ToString().ToUpper();
            if (!Aliases.TryGetValue(alias, out var uCommand))
                uCommand = alias;

            bool isTransparent = TransparentCommands.Contains(uCommand);
            if (isTransparent)
            {
                Commands[uCommand]();
                _input.Output(uCommand);
            }
            else if (_input.IsBusy)
                _input.InputText(command);
            else
            {
                if (uCommand.Length == 0)
                    uCommand = LastCommand;
                if (Commands.TryGetValue(uCommand, out var function))
                {
                    IsCopy = false;
                    NumberOfCopies = 1;
                    _model.Command = uCommand;
                    _input.Output(uCommand);
                    function();
                    if (_model.NeedsRefresh)
                        View.Refresh();
                    _input.Prompt("Command: ");
                    LastCommand = uCommand;
                }
                else
                {
                    try
                    {
                        mp.Parse(command);
                        mp.Calculate();
                        _input.Output(mp.ToString());
                    }
                    catch (MathParserException ex)
                    {
                        _input.Output($"Invalid command or expression \"{command}\": {ex.Message}");
                    }
                }
            }
        }

        private double Evaluate(ReadOnlySpan<char> Input)
        {
            try
            {
                _settings.Decimals = View.Metrics.Decimals;
                mp.Parse(Input);
                return mp.CalculateReal();
            }
            catch (MathParserException ex)
            {
                _input.Output(ex.Message);
                return double.NaN;
            }
        }

        private void Delete()
        {
            if (View.SelectOnScreen("Delete: ") > 0)
                _model.Delete();
        }

        private void All() { View.SelectAll(true, true); }
        private void Deselect() { View.SelectAll(false, true); }

        private void Distance()
        {
            var points = _input.GetLine("Distance: ");
            if (!IsNoneOrCoincident(points))
            {
                (var start, var end) = points;
                Point2D Delta = end - start;
                double Length = Vector2D.Length(Delta);
                double Angle = Vector2D.Angle(Delta) * 180 / Math.PI;
                _input.Output(string.Format("Distance = {0:0.###}, Angle = {1:0.#}°, Δx = {2:0.###}, Δy = {3:0.###}", Length, Angle, Delta.X, Delta.Y));
            }
        }

        private void Area()
        {
            if (View.SelectOnScreen("Area: ") > 0)
            {
                View.Area();
                View.SelectAll(false, false);
            }
        }

        private void MassProp()
        {
            if (View.SelectOnScreen("Mass properties: ") > 0)
            {
                View.MassProp();
                View.SelectAll(false, false);
            }
        }

        private void Height()
        {
            if (View.SelectOnScreen("Height: ") > 0)
            {
                double Value = _input.GetNumber("Height value: ");
                if (double.IsNaN(Value))
                    return;
                _model.SetHeight(Value);
                _model.ShowHeight = true;
                OptionsChanged(this, new EventArgs());
                View.SelectAll(false, false);
            }
        }

        private void Mass()
        {
            if (View.SelectOnScreen("Mass: ") > 0)
            {
                double Value = _input.GetNumber("Mass value: ");
                if (double.IsNaN(Value))
                    return;

                _model.SetMass(Value);
                _model.ShowMass = true;
                OptionsChanged(this, new EventArgs());
                View.SelectAll(false, false);
            }
        }


        private void Line()
        {
            View.SelectAll(false, true);
            var points = _input.GetLine("Line: ");
            if (!IsNoneOrCoincident(points))
                _model.AddPoly(points);
        }

        private void Circle()
        {
            View.SelectAll(false, true);
            var points = _input.GetCircle("Circle: ");
            if (!IsNoneOrCoincident(points))
            {
                double R = Vector2D.Length(points.Start - points.End);
                _model.AddCircle(points.Start, R);
            }
        }

        private void Arc()
        {
            View.SelectAll(false, true);
            var points = _input.GetLine("Arc: ");
            if (IsNoneOrCoincident(points))
                return;

            var (start, through) = points;
            if (Vector2D.PseudoLength(through - start) < Point2D.Tol)
            {
                _input.Output("The first two points are too close together to draw an arc.");
                return;
            }
            Arc arc = _model.AddArc(start, through, through);
            if (arc is null)
                return;

            View.StartFloat(arc);
            View.SetGrip(through, new Grip(arc, Kernel.Shapes.Arc.EndGrip));
            var end = _input.GetPoint("Arc: End point: ", true);
            _model.UndoCancel();
            if (end.IsNone)
            {
                arc.IsSelected = true;
                _model.Delete();
                _model.UndoCancel();
            }
        }

        private void Point()
        {
            View.SelectAll(false, true);
            var p = _input.GetPoint("Point: ", false);
            if (!p.IsNone)
                _model.AddCircle(p, 0);
        }

        private void Text()
        {
            View.SelectAll(false, true);
            var p = _input.GetPoint("Text base point: ", false);
            if (!p.IsNone)
            {
                string Contents = _input.GetText("Text content: ");
                if (Contents is null || Contents.Length == 0)
                    _input.Output("Text is empty");
                else
                {
                    string Layer = View.DrawingLayer;
                    View.DrawingLayer = "Text";
                    _model.AddText(p, Contents);
                    View.DrawingLayer = Layer;
                }
            }
        }

        private void Rectangle()
        {
            View.SelectAll(false, true);
            var points = _input.GetRectangle("Rectangle: ");
            if (!IsNoneOrCoincident(points))
            {
                (var start, var end) = points;
                Point2D P1 = new(end.X, start.Y);
                Point2D P2 = new(start.X, end.Y);
                _model.AddPoly([ start, P1, end, P2 ], true);
            }
        }

        private void Polyline() { Poly(false); }
        private void Polygon() { Poly(true); }

        private void Poly(bool isClosed)
        {
            string CommandName;
            if (isClosed)
                CommandName = "Polygon: ";
            else
                CommandName = "Polyline: ";
            View.SelectAll(false, true);
            var points = _input.GetLine(CommandName);
            if (!IsNoneOrCoincident(points))
            {
                var sh = _model.AddPoly(points, Kernel.Shapes.Poly.Block);
                sh.IsSelected = true;
                View.IsFloating = true;
                View.IsMoving = false;
                View.IsCoping = false;
                View.Refresh();
                while (true)
                {
                    var p = _input.GetPoint($"{CommandName} Next point: ", true);
                    if (p.IsNone || isClosed && p.Equals(points.Start))
                    {
                        sh.IsSelected = false;
                        if (isClosed)
                            sh.Close();
                        else
                            sh.Complete();

                        View.EndFloat();
                        break;
                    }
                    else
                    {
                        sh.AddPoint(p);
                        View.UpdateFloat();
                    }
                }
            }
        }

        private void DimAligned() { Dimline(Dim.DimensionAlign.Rotated); }
        private void DimHorizontal() { Dimline(Dim.DimensionAlign.Horizontal); }
        private void DimVertical() { Dimline(Dim.DimensionAlign.Vertical); }

        private void Dimline(Dim.DimensionAlign align)
        {
            View.SelectAll(false, true);
            var p1 = _input.GetPoint("Dimline: First point: ", false);
            if (!p1.IsNone)
            {
                _model.DimAlign = align;
                bool isFirst = true;
                Line2D constraint = Line2D.None;
                var textOffset = 0d;
                var layer = View.DrawingLayer;
                View.DrawingLayer = "Dims";
                while (true)
                {
                    var p2 = p1 + new Point2D(1, 0);
                    Dim dim = _model.AddDimLine(p1, p2);
                    View.StartFloat(dim);
                    View.SetGrip(p1, new Grip(dim, 1));
                    dim.Constraint = constraint;
                    p2 = _input.GetPoint("Dimline: Second point: ", true);
                    _model.UndoCancel();
                    if (p2.IsNone)
                    {
                        View.DrawingLayer = layer;
                        dim.IsSelected = true;
                        _model.Delete();
                        _model.UndoCancel();
                        return;
                    }
                    else
                    {
                        dim.Update();
                        Line2D line = new(p1, p2);
                        if (isFirst)
                        {
                            View.StartFloat(dim);
                            View.Regen();
                            View.SetGrip(dim.TextInsertionPoint, new Grip(dim, Dim.TextPointIndex));
                            var textPoint = _input.GetPoint("Dimline: Text position: ", true);
                            if (textPoint.IsNone)
                            {
                                dim.UpdateDimOffset();
                                textPoint = dim.TextInsertionPoint;
                            }
                            else
                                _model.UndoCancel();

                            textOffset = line.Distance(textPoint);
                            if (align == Dim.DimensionAlign.Horizontal)
                                constraint = new(textPoint, textPoint + new Point2D(1, 0));
                            else if (align == Dim.DimensionAlign.Vertical)
                                constraint = new(textPoint, textPoint + new Point2D(0, 1));
                            else
                                constraint = line.Parallel(textPoint);

                            isFirst = false;
                        }
                        else
                            dim.UpdateDimOffset();

                        dim.UpdateAll();
                    }
                    dim.Constraint = Line2D.None;
                    if (align == Dim.DimensionAlign.Rotated)
                        p1 = constraint.OffsetAtPoint(p2, -textOffset);
                    else
                        p1 = p2;
                }
            }
        }

        private void AlignDimensions()
        {
            if (View.SelectOnScreen("Align dimensions: ") > 0)
            {
                var p = _input.GetPoint("Alignment point:", false);
                if (!p.IsNone)
                {
                    _model.AlignDimensions(p);
                    View.SelectAll(false, false);
                }
            }
        }

        private void DimSection()
        {
            var layer = View.DrawingLayer;
            View.DrawingLayer = "Dims";
            if (View.SelectOnScreen("Dim Section: ") > 0)
            {
                var points = _input.GetLine("Section line: ");
                if (!IsNoneOrCoincident(points))
                {
                    int Count = _model.Count;
                    _model.AddSectionDimLines(points);
                    if (_model.Count > Count)
                    {
                        View.Regen();
                        var p = _input.GetPoint("Alignment point:", false);
                        if (!p.IsNone)
                        {
                            _model.AlignDimensions(p);
                            _model.UndoMerge();
                        }
                        View.SelectAll(false, false);
                    }
                    else
                        _input.Output("Nothing has been intersected.");
                }
            }
            View.DrawingLayer = layer;
       }

        private void Block()
        {
            if ( View.SelectOnScreen("Block: ") > 0)
            {
                var name = _input.GetText("Block name: ");
                if (name.Length == 0)
                {
                    name = RandomString();
                    _input.Output($"Anonimous block \"{name}\" created.");
                }
                var p = _input.GetPoint("Base point: ", false);
                if (p.IsNone)
                    p = new Point2D(0, 0);

                View.AddStaticBlock(name, p);
            }
        }

        private void Insert()
        {
            string name = _input.GetText("Block name: ");
            if (name.Length == 0)
                return;

            Point2D p1 = new(0, 0);
            BlockRef blockRef = View.Insert(name, p1, 0);
            if (blockRef is not null)
            {
                View.StartFloat(blockRef);
                View.SetGrip(p1, new Grip(blockRef, 0));
                var p2 = _input.GetPoint("Insertion point: ", true);
                if (!p2.IsNone)
                    blockRef.Update();
                else
                    _model.Delete();
            }
        }

        private static string RandomString()
        {
            Random rand = new();
            string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
            return new string([.. chars.Select(c => chars[rand.Next(chars.Length)]).Take(8)]);
        }

        private void Move()
        {
            if (IsCopy || View.SelectOnScreen("Move: ") > 0)
            {
                string prompt = IsCopy ? "Copy (Move): " : "Move: ";
                View.IsCoping = IsCopy;
                View.IsMoving = true;
                var points = _input.GetLine(prompt);
                if (!IsNoneOrCoincident(points))
                {
                    (var start, var end) = points;
                    Point2D delta = end - start;
                    if (IsCopy)
                    {
                        _model.ReserveCapacity(NumberOfCopies);
                        for (int i = 1; i <= NumberOfCopies; i++)
                        {
                            _model.CopyMove(delta * i);
                            if (i > 1)
                                _model.UndoMerge();

                            Application.DoEvents();
                        }
                    }
                    else
                        _model.Move(delta);

                    View.SelectAll(false, IsCopy);
                }
                View.IsCoping = false;
            }
        }

        private void Scale()
        {
            if (IsCopy || View.SelectOnScreen("Scale: ") > 0)
            {
                var prompt = IsCopy ? "Copy (Scale): " : "Scale: ";
                var p1 = _input.GetPoint(prompt + " Center point: ", false);
                if (!p1.IsNone)
                {
                    var p2 = _input.GetPoint("Scale factor: ", true);
                    if (!p2.IsNone && !IsNoneOrCoincident((p1, p2)))
                    {
                        var k = Vector2D.Length(p2 - p1);
                        Point2D p = p1 * (1 - k);
                        if (IsCopy)
                            _model.CopyScale(p, k);
                        else
                            _model.Scale(p, k);
                    }
                    View.SelectAll(false, IsCopy);
                }
            }
        }

        private void Rotate()
        {
            if (IsCopy || View.SelectOnScreen("Rotate: ") > 0)
            {
                var prompt = IsCopy ? "Copy (Rotate): " : "Rotate: ";
                var p1 = _input.GetPoint(prompt + "Center point: ", false);
                if (!p1.IsNone)
                {
                    var p2 = _input.GetPoint("Rotation angle: ", true);
                    if (!p2.IsNone)
                    {
                        if (!IsNoneOrCoincident((p1, p2)))
                        {
                            Point2D p = p2 - p1;
                            var a = Vector2D.Angle(p);
                            _model.ReserveCapacity(NumberOfCopies);
                            for (int i = 1; i <= NumberOfCopies; i++)
                            {
                                var a_i = a * i;
                                var cos = Math.Cos(a_i);
                                var sin = Math.Sin(a_i);
                                p.X = p1.X - p1.X * cos + p1.Y * sin;
                                p.Y = p1.Y - p1.X * sin - p1.Y * cos;
                                if (IsCopy)
                                {
                                    _model.CopyRotate(p, cos, sin);
                                    if (i > 1)
                                        _model.UndoMerge();

                                    Application.DoEvents();
                                }
                                else
                                    _model.Rotate(p, cos, sin);
                            }
                        }
                        View.SelectAll(false, IsCopy);
                    }
                }
            }
        }

        private void Mirror()
        {
            if (IsCopy || View.SelectOnScreen("Mirror: ") > 0)
            {
                string prompt = IsCopy ? "Copy (Mirror): " : "Mirror: ";
                var points = _input.GetLine(prompt);
                if (!IsNoneOrCoincident(points))
                {
                    (var start, var end) = points;
                    Point2D point = Vector2D.Norm(end - start);
                    double cos = (point.X - point.Y) * (point.X + point.Y);
                    double sin = 2 * point.X * point.Y;
                    point.X = start.X - start.X * cos - start.Y * sin;
                    point.Y = start.Y - start.X * sin + start.Y * cos;
                    if (IsCopy)
                        _model.CopyMirror(point, cos, sin);
                    else
                        _model.Mirror(point, cos, sin);

                    View.SelectAll(false, IsCopy);
                }
            }
        }

        private void Copy()
        {
            if (View.SelectOnScreen("Copy: ") > 0)
            {
                List<string> keywords = ["ROTATE", "MIRROR", "SCALE"];
                string keyword = _input.GetKeyword("Copy: Enter for <Move> or select keyword [Rotate, Mirror, Scale]: ", keywords);
                if (keyword is null)
                    return;

                IsCopy = true;
                if (keyword.Length == 0)
                    Move();
                else if (keyword == "ROTATE")
                    Rotate();
                else if (keyword == "MIRROR")
                    Mirror();
                else if (keyword == "SCALE")
                    Scale();
            }
        }

        private void Array()
        {
            int n = View.SelectOnScreen("Array: ");
            if (n > 0)
            {
                List<string> keywords = ["POLAR"];
                string keyword = _input.GetKeyword("Array: Enter for <Linear> or select keyword [Polar]: ", keywords);
                if (keyword is null)
                    return;

                double d = _input.GetNumber("Array: Number of copies: ");
                if (double.IsNaN(d) || d == 0)
                    return;

                NumberOfCopies = (int)d;
                IsCopy = true;
                bool MergeUndo = _model.Count < n * NumberOfCopies;
                if (MergeUndo)
                    _model.StartUndoRecord();

                if (keyword.Length == 0)
                    Move();
                else if (keyword == "POLAR")
                    Rotate();

                if (MergeUndo)
                    _model.StopUndoRecord();
            }
        }

        private void Offset()
        {
            if (View.SelectOnScreen("Offset: ") > 0)
            {
                double d = _input.GetNumber("Offset distance: ");
                if (!double.IsNaN(d) && d != 0)
                    _model.Offset(d);

                View.SelectAll(false, false);
            }
        }

        private void Stretch()
        {
            View.SelectAll(false, true);
            var points = _input.GetRectangle("Stretch region: ");
            if (!IsNoneOrCoincident(points))
            {
                Box2D box = new(points.Start, points.End);
                View.Stretch(box);
            }
            View.SelectAll(false, false);
        }

        private void Edit()
        {
            while (true)
            {
                if (View.SelectSingle("Select text: "))
                {
                    View.Redraw();
                    while (true)
                    {
                        if (_input.GetTextContents())
                        {
                            string content = _input.GetText("Enter text: ");
                            if (!string.IsNullOrEmpty(content))
                                _model.SetTextContents(content);

                            View.SelectAll(false, false);
                            return;
                        }
                        else
                        {
                            _input.Output("This object is not a text");
                            break;
                        }
                    }
                }
                else
                    break;
            }
        }

        private void Close()
        {
            if (View.SelectOnScreen("Close: ") > 0)
            {
                _model.Close();
                View.SelectAll(false, false);
            }
        }

        private void Explode()
        {
            if (View.SelectOnScreen("Explode: ") > 0)
                _model.Explode();
        }

       private void Join()
        {
            if (View.SelectOnScreen("Join: ") > 0)
                _model.Join();
        }

        private void Break()
        {
            if (View.SelectOnScreen("Break: ") > 0)
            {
                var p = _input.GetPoint("Select breaking point: ", false);
                if (p.IsNone)
                    return;

                View.Break(p);
                View.Regen();
            }
        }

        private void Lengthen()
        {
            List<string> keywords = ["TOTAL", "DELTA"];
            string keyword = _input.GetKeyword("Lengthen: Enter for <Total> or select keyword [Total, Delta]: ", keywords);
            if (keyword is null)
                return;

            bool delta = keyword == "DELTA";
            string prompt;
            if (delta)
                prompt = "Lengthen: Delta length: ";
            else
                prompt = "Lengthen: Total length: ";

            double distance = _input.GetNumber(prompt);
            if (distance == 0)
                return;

            bool osnapOn = View.OsnapOn;
            bool snapOn = View.SnapOn;
            View.OsnapOn = false;
            View.SnapOn = false;
            while (true)
            {
                var p = _input.GetPoint("Lengthen: Click a line: ", false);
                if (p.IsNone)
                    break;

                if (View.Lengthen(p, distance, delta))
                    View.Regen();
                else
                    _input.Output("No line found at this point.");
            }
            View.OsnapOn = osnapOn;
            View.SnapOn = snapOn;
        }

        private void RemoveVertex()
        { 
            if (View.SelectOnScreen("Remove vertex: ") > 0)
            {
                var p = _input.GetPoint("Select a vertex to be removed: ", false);
                if (p.IsNone)
                    return;

                View.RemoveVertex(p);
                View.Regen();
            }
        }

        private void AddVertex()
        {
            if (View.SelectOnScreen("Add vertex: ") > 0)
            {
                var p = _input.GetPoint("Vertex insertion point: ", false);
                if (p.IsNone)
                    return;

                View.AddVertex(p);
                View.Regen();
            }
        }

        private void Union()
        {
            if (View.SelectOnScreen("Union: ") > 0)
                _model.Union();
        }

        private void Intersect()
        {
            if (View.SelectOnScreen("Intersect: ") > 0)
                _model.Intersect();
        }

        private void Subtract()
        {
            if (View.SelectSingle("Subtract from: "))
            {
                View.Redraw();
                if (View.SelectOnScreen("Select objects to subtract: ", true) > 0)
                    _model.Subtract();
            }
        }

        private void Slice()
        {
            if (View.SelectOnScreen("Slice: ") > 0)
            {
                var points =  _input.GetLine("Section line: ");
                if (!IsNoneOrCoincident(points))
                    _model.Slice(points.Start, points.End);

                View.SelectAll(false, false);
            }
        }

        private void ZoomIn()
        {
            try 
            {
                View.ZoomDelta(1.5, false);
            }
            catch
            {
                _input.Prompt("Unable to zoom.");
                View.ZoomAll();
            }
        }
        private void ZoomOut()
        {
            try
            {
                View.ZoomDelta(0.5, false);
            }
            catch
            {
                _input.Prompt("Unable to zoom.");
                View.ZoomAll();
            }
        }
        private void ZoomAll() => View.ZoomAll();

        private void ZoomWindow()
        {
            var points = _input.GetRectangle("Window: ");
            if (!IsNoneOrCoincident(points))
                View.ZoomWindow(new Box2D(points.Start, points.End));
        }

        private void Grid()
        {
            View.GridOn = !View.GridOn;
            OptionsChanged(this, new EventArgs());
            View.Regen();
        }

        private void Snap()
        {
            View.SnapOn = !View.SnapOn;
            OptionsChanged(this, new EventArgs());
        }

        private void Ortho()
        {
            View.OrthoOn = !View.OrthoOn;
            OptionsChanged(this, new EventArgs());
        }

        private void Osnap()
        {
            View.OsnapOn = !View.OsnapOn;
            OptionsChanged(this, new EventArgs());
        }

        private bool IsNoneOrCoincident((Point2D start, Point2D end) points)
        {
            (var start, var end) = points;
            if (start.IsNone || end.IsNone)
            {
                _input.Output("Error! No points.");
                return true;
            }
            if (start.Equals(end))
            {
                _input.Output("Error! Coincident points.");
                return true;
            }
            return false;
        }

        private void Undo()
        {
            View.Undo();
            OptionsChanged(this, new EventArgs());
        }

        private void Redo()
        {
            View.Redo();
            OptionsChanged(this, new EventArgs());
        }

        private void LayerOn()
        {
            _model.UndoRecordLayers();
            foreach (KeyValuePair<string, Layer> kvp in _model.Layers)
                kvp.Value.Visible = true;
        }

        private void LayerOff()
        {
            View.SelectAll(false, true);
            if (View.SelectSingle("Select an object which layer to be turned off: "))
            {
                _model.UndoRecordLayers();
                _model.Layers[_model.SelectedLayer].Visible = false;
                View.SelectAll(false, false);
            }
        }

        private void LayerUnlock()
        {
            foreach (KeyValuePair<string, Layer> kvp in _model.Layers)
                kvp.Value.Locked = false;
        }

        private void LayerLock()
        {
            View.SelectAll(false, true);
            if (View.SelectSingle("Select an object which layer to be locked: "))
            {
                _model.UndoRecordLayers();
                _model.Layers[_model.SelectedLayer].Locked = true;
                View.SelectAll(false, false);
            }
        }

        private void LayerIsolate()
        {
            View.SelectAll(false, true);
            if (View.SelectSingle("Select an object which layer to be isolated: "))
            {
                _model.UndoRecordLayers();
                foreach (KeyValuePair<string, Layer> kvp in _model.Layers)
                    kvp.Value.Locked = true;
                string s = _model.SelectedLayer;
                _model.Layers[s].Locked = false;
                View.DrawingLayer = s;
                View.SelectAll(false, false);
            }
        }

        private void LayerCurrent()
        {
            View.SelectAll(false, true);
            if (View.SelectSingle("Select an object which layer to become current: "))
            {
                View.DrawingLayer = _model.SelectedLayer;
                View.SelectAll(false, false);
            }
        }

        private void Back()
        {
            if (View.SelectOnScreen("Select objects to send to back: ") > 0)
            {
                _model.DrawOrder(false);
                View.SelectAll(false, false);
            }
        }

        private void Front()
        {
            if (View.SelectOnScreen("Select objects to send to front: ") > 0)
            {
                _model.DrawOrder(true);
                View.SelectAll(false, false);
            }
        }
    }
}