using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Windows.Foundation;
using Windows.UI.Input.Inking;
using Windows.UI.Input.Inking.Analysis;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Shapes;

namespace InkPen.Services.Ink
{
    public class InkRecognitionService
    {
        private readonly Canvas _recognitionCanvas;
        private readonly InkCanvas _inkCanvas;
        

        InkAnalyzer inkAnalyzer = new InkAnalyzer();
        IReadOnlyList<InkStroke> inkStrokes = null;
        InkAnalysisResult inkAnalysisResults = null;


        public InkRecognitionService(Canvas reconigtionCanvas, InkCanvas inkCanvas)
        {
            _recognitionCanvas = reconigtionCanvas;
            _inkCanvas = inkCanvas;


        }

        private void DrawText( string recognizedText, Rect boundingRect)
        {
            TextBlock text = new TextBlock();
            Canvas.SetTop(text, boundingRect.Top);
            Canvas.SetLeft(text, boundingRect.Left);

            text.Text = recognizedText;
            text.FontSize = boundingRect.Height;

            _recognitionCanvas.Children.Add(text);

        }





        public void DrawEllipse(InkAnalysisInkDrawing shape)
        {
            var points = shape.Points;
            Ellipse ellipse = new Ellipse();

            ellipse.Width = shape.BoundingRect.Width;
            ellipse.Width = shape.BoundingRect.Height;

            Canvas.SetTop(ellipse, shape.BoundingRect.Top);
            Canvas.SetLeft(ellipse, shape.BoundingRect.Left);

            var brush = new SolidColorBrush(Windows.UI.ColorHelper.FromArgb(255, 0, 0, 255));
            ellipse.Stroke = brush;
            ellipse.StrokeThickness = 2;
            _recognitionCanvas.Children.Add(ellipse);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="shape"></param>

        public void DrawPolygon(InkAnalysisInkDrawing shape)
        {

            List<Point> points = new List<Point>(shape.Points);
            Polygon polygon = new Polygon();

            foreach (Point point in points)
            {
                polygon.Points.Add(point);
            }

            var brush = new SolidColorBrush(Windows.UI.ColorHelper.FromArgb(255, 0, 0, 255));
            polygon.Stroke = brush;
            polygon.StrokeThickness = 2;
            _recognitionCanvas.Children.Add(polygon);
        }


        public async Task RecognizeStrokes()
        {


            inkStrokes = _inkCanvas.InkPresenter.StrokeContainer.GetStrokes();
            // Ensure an ink stroke is present.
            if (inkStrokes.Count > 0)
            {
                inkAnalyzer.AddDataForStrokes(inkStrokes);


                inkAnalysisResults = await inkAnalyzer.AnalyzeAsync();

                if(inkAnalysisResults.Status == InkAnalysisStatus.Updated)
                {
                    var inkwordNodes = inkAnalyzer.AnalysisRoot.FindNodes(
                        InkAnalysisNodeKind.InkWord);

                    foreach (InkAnalysisInkWord node in inkwordNodes)
                    {
                        DrawText(node.RecognizedText, node.BoundingRect);


                        foreach( var strokeId in node.GetStrokeIds())
                        {
                            var stroke = _inkCanvas.InkPresenter.StrokeContainer.GetStrokeById(strokeId);
                            stroke.Selected = true;

                        }
                        inkAnalyzer.RemoveDataForStrokes(node.GetStrokeIds());

                    }
                    _inkCanvas.InkPresenter.StrokeContainer.DeleteSelected();
                   // Have ink strokes on the canvas changed?
               
                    var inkdrawingNodes =
                       inkAnalyzer.AnalysisRoot.FindNodes(
                           InkAnalysisNodeKind.InkDrawing);
                    // Iterate through each InkDrawing node.
                    // Draw recognized shapes on recognitionCanvas and
                    // delete ink analysis data and recognized strokes.
                    foreach (InkAnalysisInkDrawing node in inkdrawingNodes)
                    {
                        if (node.DrawingKind == InkAnalysisDrawingKind.Drawing)
                        {
                            // Catch and process unsupported shapes (lines and so on) here.
                        }
                        // Process generalized shapes here (ellipses and polygons).
                        else
                        {
                            // Draw an Ellipse object on the recognitionCanvas (circle is a specialized ellipse).
                            if (node.DrawingKind == InkAnalysisDrawingKind.Circle || node.DrawingKind == InkAnalysisDrawingKind.Ellipse)
                            {
                                DrawEllipse(node);
                            }
                            // Draw a Polygon object on the recognitionCanvas.
                            else
                            {
                                DrawPolygon(node);
                            }
                            foreach (var strokeId in node.GetStrokeIds())
                            {
                                var stroke = _inkCanvas.InkPresenter.StrokeContainer.GetStrokeById(strokeId);
                                stroke.Selected = true;
                                
                            }
                        }
                        inkAnalyzer.RemoveDataForStrokes(node.GetStrokeIds());
                    }
                    _inkCanvas.InkPresenter.StrokeContainer.DeleteSelected();
                }
            }



        }


        //delete




    }
}