using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;

namespace Dungeon
{
    public class DungeonTask
    {
        public static MoveDirection[] FindShortestPath(Map map)
        {
            var shortWay = GetShortWay(map);
            var wayToTheCheck = GetWayToTheCheck(map);
            if (shortWay is null) return new MoveDirection[0];
            if (shortWay.Any(point => map.Chests.Contains(point))) return GetIfNotExit(shortWay);
            if (wayToTheCheck.FirstOrDefault() is null) return GetIfNotCheck(shortWay);
            var wayToExitThisCheck = GetWayToExitThisCheck(wayToTheCheck, map);
            var ans = (wayToExitThisCheck.Item1
                .Reverse()
                .Concat(wayToExitThisCheck.Item2.Reverse().Skip(1)));
            return GetFiniteWay(ans);
        }

        public static SinglyLinkedList<Point> GetShortWay(Map map)
        {
           return BfsTask.FindPaths(map, map.InitialPosition, new Point[] { map.Exit })
                .OrderBy(x => x.Length)
                .FirstOrDefault();
        }

        public static IEnumerable<SinglyLinkedList<Point>> GetWayToTheCheck(Map map)
        {
            return BfsTask.FindPaths(map, map.InitialPosition, map.Chests);
        }

        public static Tuple<SinglyLinkedList<Point>, SinglyLinkedList<Point>> GetWayToExitThisCheck
            (IEnumerable<SinglyLinkedList<Point>> wayToTheCheck,Map map)
        {
            return wayToTheCheck
                .Select(pathToChest =>
                {
                    var shortWayInExit = BfsTask.FindPaths(
                        map, pathToChest.Value, new Point[] { map.Exit })
                        .OrderBy(x => x.Length)
                        .First();
                    return Tuple.Create(pathToChest, shortWayInExit);
                })
                .OrderBy(ite => ite.Item1.Length + ite.Item2.Length)
                .FirstOrDefault();
        }

        public static MoveDirection[] GetFiniteWay(IEnumerable<Point> ans)
        {
            return ans
                .Zip(ans.Skip(1), (previousPoint, point) =>
                     new Size(point.X - previousPoint.X,point.Y - previousPoint.Y))
                .Select(offset => Walker.ConvertOffsetToDirection(offset))
                .ToArray();
        }

        public static MoveDirection[] GetIfNotExit(SinglyLinkedList<Point> shortWay)
        {
           return shortWay.Reverse()
                .Zip(shortWay.Reverse().Skip(1), (previousPoint, point) =>
                     new Size(point.X - previousPoint.X,point.Y - previousPoint.Y))
                .Select(offset => Walker.ConvertOffsetToDirection(offset))
                .ToArray();
        }

        public static MoveDirection[] GetIfNotCheck(SinglyLinkedList<Point> shortWay)
        {
            return shortWay.Reverse()
                .Zip(shortWay.Reverse().Skip(1), (previousPoint, point) =>
                     new Size(point.X - previousPoint.X,point.Y - previousPoint.Y))
                .Select(offset => Walker.ConvertOffsetToDirection(offset))
                .ToArray();
        }
    }
}