using System;
using System.Timers;
using System.Windows;
using OpenMetaverse;
using Xenki.Framework;
using System.Drawing;
using System.Windows.Media.Imaging;
using System.IO;
using OpenMetaverse.Imaging;
//using System.IO;
//using System.Windows.Media;
//using System.Drawing.Imaging;
//using OpenMetaverse.Imaging;



namespace Xenki.DefaultNetwork
{
    public delegate void OnLogDelegate(string msg);
    public delegate void OnMessageChatDelegate(string msg);


    class DefaultNetwork
    {
        private readonly GridClient m_gridclient;
        private readonly IRenderer m_renderer;
        public static  IPrimitiveData m_primitiveData;

        private double[,] m_terrainpatch = new double[256,256];
        private Timer m_terrainSetTimer = new Timer(1000);
        private Timer m_cameraTimer = new Timer(1000);
        private int m_cameraSeed;
        private Random m_random = new Random(1338);
        private DefaultTexture.DefaultTexture defaultTexture;

       public static TextureCache textureCauche;

        public event OnLogDelegate OnLog;
        public event OnMessageChatDelegate OnMessageChat;

        DefaultAgent.MessageChatManage chat;

        //AssetManager asset ;

        private void log(string v)
        {
            if (OnLog != null)
                OnLog(v);
        }

        public DefaultNetwork(IRenderer m_renderer,IPrimitiveData m_primitiveData)
        {

            log("Creating class");
            m_gridclient = new GridClient();
            this.m_renderer = m_renderer;
            DefaultNetwork.m_primitiveData = m_primitiveData;
            defaultTexture = new Xenki.DefaultTexture.DefaultTexture(m_gridclient);

            m_gridclient.Settings.USE_TEXTURE_CACHE = true;
            m_gridclient.Settings.TEXTURE_CACHE_DIR = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "textures");

            // Important
            m_gridclient.Settings.MULTIPLE_SIMS = false;
            m_gridclient.Settings.OBJECT_TRACKING = false;

            Settings.LOG_LEVEL = Helpers.LogLevel.Debug;
            m_gridclient.Throttle.Land = 10000;

            log("Initialising callbacks");
            m_gridclient.Objects.OnNewPrim += Objects_OnNewPrim;
            m_gridclient.Objects.OnObjectUpdated += Objects_OnObjectUpdated;
            m_gridclient.Objects.OnObjectKilled += Objects_OnObjectKilled;
            m_gridclient.Network.OnConnected += Network_OnConnected;
            m_gridclient.Terrain.OnLandPatch += Terrain_OnLandPatch;
            m_gridclient.Network.OnSimConnected += Network_OnSimConnected;
             
           
            defaultTexture.OnDownloadFinished += new Xenki.DefaultTexture.DefaultTexture.DownloadFinishedCallback(defaultTexture_OnDownloadFinished);
           
             chat = new Xenki.DefaultAgent.MessageChatManage(m_gridclient);
             chat.OnChat += new Xenki.DefaultAgent.OnChatDelegate(chat_OnChat);

             textureCauche = new TextureCache(m_gridclient);

            Logger.OnLogMessage += Logger_OnLogMessage;

            m_terrainSetTimer.Elapsed += m_terrainSetTimer_Elapsed;
            m_cameraTimer.Elapsed += m_cameraTimer_Elapsed;
        }

        void chat_OnChat(string msg)
        {
            if (OnMessageChat != null)
                OnMessageChat(msg);
        }

        void defaultTexture_OnDownloadFinished(ImageDownload imageIDDownload, bool success)
        {
            byte[] bytes;
            bytes = DefaultNetwork.m_primitiveData.RetireveTextureData(imageIDDownload.ID);
            if (bytes == null || bytes.Length <= 0)
            {
                DefaultNetwork.m_primitiveData.CacheDownloadedTexture(imageIDDownload);
            }
            if (success == true)
            {
                textureCauche.SaveImageToCache(imageIDDownload.ID, imageIDDownload.AssetData);

                m_renderer.UpdatePrimTexture(imageIDDownload.ID);
            }
        }

       

      
        void Objects_OnObjectUpdated(Simulator simulator, ObjectUpdate update, ulong regionHandle, ushort timeDilation)
        {
            
        }

        void m_cameraTimer_Elapsed(object sender, ElapsedEventArgs e)
        {
            m_gridclient.Throttle.Land = 40000;
            m_gridclient.Throttle.Task = 40000;

            m_gridclient.Self.Movement.Camera.Far = 1024.0f;

            m_gridclient.Self.Movement.Camera.LookAt(
                new Vector3((float) m_random.NextDouble()*256.0f, (float) m_random.NextDouble()*256.0f, 256.0f),
                new Vector3((float) m_random.NextDouble()*256.0f, (float) m_random.NextDouble()*256.0f, 0.0f));
        }

        void Network_OnSimConnected(Simulator simulator)
        {
            m_cameraTimer.Start();
            m_gridclient.Self.Movement.Camera.Far = 512.0f;
            m_gridclient.Self.Movement.Camera.LookAt(new Vector3(0, 0, 256), new Vector3(256, 256, 0));
        }

        void m_terrainSetTimer_Elapsed(object sender, ElapsedEventArgs e)
        {
            log("Refreshing terrain...");
            m_renderer.SetTerrain(m_terrainpatch);
        }

        void Terrain_OnLandPatch(Simulator simulator, int x, int y, int width, float[] data)
        {
            if(width != 16)
                return;

            x *= 16;
            y *= 16;

            int i = 0;

            for(int tx=0;tx<16;tx++)
            {
                for(int ty=0;ty<16;ty++)
                {
                    m_terrainpatch[x + ty, y + tx] = data[i++];
                }
            }

            m_terrainSetTimer.Stop();
            m_terrainSetTimer.AutoReset = false;
            m_terrainSetTimer.Start();

            //m_renderer.SetTerrain(m_terrainpatch);

            log("Setting terrain patch " + x + "," + y + " midval: " + m_terrainpatch[x + 8, y + 8] + "/" + data[128]);
        }

        void Network_OnConnected(object sender)
        {
            // Download whole scene here.
            //textureCache = new TextureCache(m_gridclient);
            m_gridclient.Self.Movement.Camera.LookAt(new Vector3(128, 128, 192), new Vector3(128, 128, 0));
        }

        void Logger_OnLogMessage(object message, Helpers.LogLevel level)
        {
            log(message.ToString());
        }

        public void RequestTexture(UUID tex)
        {
            m_gridclient.Assets.RequestImage(tex, ImageType.Normal);
        }

        public void Start(string username, string lastname, string password)
        {
            log("Calling login method");

            LoginParams login = m_gridclient.Network.DefaultLoginParams(username, lastname,password
                                                                      ,"XenkiViewer",
                                                                        System.Windows.Forms.Application.ProductVersion);
            //login.URI = "http://osgrid.org:8002/";
            m_gridclient.Network.BeginLogin(login);
        }

        public void Stop()
        {
            m_gridclient.Network.Logout();
        }

        void Objects_OnObjectKilled(Simulator simulator, uint objectID)
        {
            //m_renderer.RemovePrimitive(objectID);
        }

        void Objects_OnNewPrim(Simulator simulator, Primitive prim, ulong regionHandle, ushort timeDilation)
        {
            try
            {
                
                //log("Adding new primitive to Renderer scene: " + prim.LocalID + " at " + prim.Position);
                DownLoadTextureAndCache(prim.Textures.DefaultTexture.TextureID);

                m_renderer.AddPrimitive(prim.LocalID, prim); 

            } catch(Exception e)
            {
                MessageBox.Show(e.ToString());
            }
        }

       //public static TextureCache textureCache;

        void DownLoadTextureAndCache(UUID textureID)
        {
           // asset.Cache = textureCache;
            //asset.RequestAsset(textureID, AssetType.Texture, true);
            byte[] imagebytes = DefaultNetwork.m_primitiveData.RetireveTextureData(textureID);
            if (imagebytes != null && imagebytes.Length > 0)
                return;
            if (DefaultNetwork.m_primitiveData.UnAttachedTextures.ContainsValue(textureID) == true)
                return;

            defaultTexture.RequestTexture(textureID);
           

        }
        

       
    }
}