using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Linq;
using System.IO;
using System.Net;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

namespace PGN
{
    public class Tileset : GameAsset
    {
        int width;

        public int Width
        {
            get { return width; }
        }
        int height;

        public int Height
        {
            get { return height; }
        }
        int tileSize;

        public int TileSize
        {
            get { return tileSize; }
        }
        Tile[,] tiles;

        public Tile GetTile(Vector2 v)
        {
            return tiles[(int)v.X-1, (int)v.Y-1];
        }

        public Tile GetTile(int x, int y)
        {
            return tiles[x-1, y-1];
        }

        Texture2D texture;

        public Texture2D Texture
        {
            get { return texture; }
        }

        public Texture2D GetTexture(GraphicsDevice g)
        {
            if (texture != null)
                return texture;
            if (!IsReady)
                DownloadAsset();
            texture = Texture2D.FromStream(g, new FileStream(FilePath, FileMode.Open));
            return texture;
        }

        public bool IsCompatibleTileset()
        {
            return (tileSize == Utils.TILESIZE);
        }

        public string GetFilePath()
        {
            if (!File.Exists(FilePath))
                throw new Exception("File is not ready!");
            return FilePath;
        }

        public string FilePath
        {
            get { return "UContent\\Tilesets\\" + hash + ".png"; }
        }

        public void DownloadAsset()
        {
            if (IsReady)
                return; //We have this asset already
            WebClient client = new WebClient();
            var remotePath = string.Format("{0}{1}.png", Utils.CDN, hash);
            client.DownloadFile(remotePath, FilePath);
        }

        public bool IsReady
        {
            get { return File.Exists("UContent\\Tilesets\\" + hash + ".png"); }
        }

        public static Tileset FromHash(string hash)
        {
            var path = "UContent\\Tilesets\\" + hash + ".xml";
            if (File.Exists(path))
                return FromManifest(path);
            if (!Directory.Exists("UContent\\Tilesets\\"))
                Directory.CreateDirectory("UContent\\Tilesets\\");
            WebClient client = new WebClient();
            var remotePath = string.Format("{0}{1}.xml", Utils.CDN, hash);
            client.DownloadFile(remotePath, path);
            return FromManifest(path);
        }

        public static Tileset FromManifest(string filename)
        {
            var doc = XDocument.Load(filename);
            Tileset set = new Tileset();
            set.width = Convert.ToInt32(doc.Element("tileset").Attribute("width").Value);
            set.height = Convert.ToInt32(doc.Element("tileset").Attribute("height").Value);
            set.hash = doc.Element("tileset").Attribute("hash").Value;
            set.tileSize = Convert.ToInt32(doc.Element("tileset").Attribute("tilesize").Value);
            if (!set.IsCompatibleTileset())
                throw new Exception("tileSize mismatch - not valid for this game");

            set.tiles = new Tile[set.width, set.height];

            foreach (var tile in doc.Element("tileset").Elements("tile"))
            {
                var offsetX = Convert.ToInt32(tile.Attribute("offsetX").Value);
                var offsetY = Convert.ToInt32(tile.Attribute("offsetY").Value);
                var playerPass = (PlayerPass)Convert.ToByte(tile.Element("playerPass").Value);
                set.tiles[offsetX-1, offsetY-1] = new Tile()
                {
                    Offset = new Point(offsetX, offsetY),
                    PlayerPass = playerPass,
                    TilesetHash = set.hash
                };
            }

            return set;
        }
    }
}