using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Sailboat
{
    internal abstract class AbstractMap
    {
        IDrawingObject _drawingObject = null;
        protected int[,] _map = null;
        //ширина и высота карты
        protected int _width;
        protected int _height;
        //ширина и высота ячейки
        protected float _size_x;
        protected float _size_y;
        protected readonly Random _random = new();
        protected readonly int _freeRoad = 0;
        protected readonly int _barrier = 1;

        public Bitmap CreateMap(int width, int height, IDrawingObject drawningObject)
        {
            _width = width;
            _height = height;
            _drawingObject = drawningObject;
            GenerateMap();
            while (!SetObjectOnMap())
            {
                GenerateMap();
            }
            return DrawMapWithObject();
        }
        public Bitmap MoveObject(Direction direction)
        {
            (float leftX, float topY, float rightX, float bottomY) = _drawingObject.GetCurrentPosition();

            float boatWidth = rightX - leftX;
            float boatHeight = bottomY - topY;
            for (int i = 0; i < _map.GetLength(0); i++)
            {
                for (int j = 0; j < _map.GetLength(1); j++)
                {
                    if (_map[i, j] == _barrier)
                    {
                        switch (direction)
                        {
                            case Direction.Up:
                                if (_size_y * (j + 1) >= topY - _drawingObject.Step && _size_y * (j + 1) < topY && _size_x * (i + 1) > leftX
                                    && _size_x * (i + 1) <= rightX)
                                {
                                    return DrawMapWithObject();
                                }
                                break;
                            case Direction.Down:
                                if (_size_y * j <= bottomY + _drawingObject.Step && _size_y * j > bottomY && _size_x * (i + 1) > leftX
                                    && _size_x * (i + 1) <= rightX)
                                {
                                    return DrawMapWithObject();
                                }
                                break;
                            case Direction.Left:
                                if (_size_x * (i + 1) >= leftX - _drawingObject.Step && _size_x * (i + 1) < leftX && _size_y * (j + 1) < bottomY
                                    && _size_y * (j + 1) >= topY)
                                {
                                    return DrawMapWithObject();
                                }
                                break;
                            case Direction.Right:
                                if (_size_x * i <= rightX + _drawingObject.Step && _size_x * i > leftX && _size_y * (j + 1) < bottomY
                                    && _size_y * (j + 1) >= topY)
                                {
                                    return DrawMapWithObject();
                                }
                                break;
                        }
                    }
                }
            }
            if (true)
            {
                _drawingObject.MoveObject(direction);
            }
            return DrawMapWithObject();
        }

        private bool SetObjectOnMap()
        {
            (float leftX, float topY, float rightX, float bottomY) = _drawingObject.GetCurrentPosition();
             if (_drawingObject == null || _map == null)
             {
                 return false;
             }

             float boatWidth = rightX - leftX;
             float boatHeight = bottomY - topY;

             int x = _random.Next(0, 10);
             int y = _random.Next(0, 10);
             for (int i = 0; i < _map.GetLength(0); ++i)
             {
                 for (int j = 0; j < _map.GetLength(1); ++j)
                 {
                     if (_map[i, j] == _barrier)
                     {
                         if (x + boatWidth >= _size_x * i && x <= _size_x * i && y + boatHeight > _size_y * j && y <= _size_y * j)
                         {
                             return false;
                         }
                     }
                 }
             }
             _drawingObject.SetObject(x, y, _width, _height);
             return true;
        }
            private Bitmap DrawMapWithObject()
            {
                Bitmap bmp = new(_width, _height);
                if (_drawingObject == null || _map == null)
                {
                    return bmp;
                }
                Graphics gr = Graphics.FromImage(bmp);
                for (int i = 0; i < _map.GetLength(0); ++i)
                {
                    for (int j = 0; j < _map.GetLength(1); ++j)
                    {
                        if (_map[i, j] == _freeRoad)
                        {
                            DrawRoadPart(gr, i, j);
                        }
                        else if (_map[i, j] == _barrier)
                        {
                            DrawBarrierPart(gr, i, j);
                        }
                    }
                }
                _drawingObject.DrawingObject(gr);
                return bmp;
            } 
        

        protected abstract void GenerateMap();
        protected abstract void DrawRoadPart(Graphics g, int i, int j);
        protected abstract void DrawBarrierPart(Graphics g, int i, int j);
    
    }
}