#ifndef ITEXTURE2D11_H__
#define ITEXTURE2D11_H__

#include "render/ITexture2D.h"
#include "render/dx11/IRenderTargetViewDX11.h"
#include "render/dx11/IShaderResourceView11.h"
#include "render/dx11/ISurface11.h"
#include "ResourceManager.h"
#include <d3d11.h>
#include <dxgi.h>
#include <d3dx11.h>
#include <vector>
#include "Globals.h"
#include <log/CLog.h>

namespace LifeGraphics
{
	class ITexture2D11 : public ITexture2D
	{
	private:
		int FormatToSize(DXGI_FORMAT format)
		{
			switch(format)
			{
			case DXGI_FORMAT_R32G32B32A32_TYPELESS:
			case DXGI_FORMAT_R32G32B32A32_FLOAT:
			case DXGI_FORMAT_R32G32B32A32_UINT:
			case DXGI_FORMAT_R32G32B32A32_SINT:
				return 16;
			case DXGI_FORMAT_R32G32B32_TYPELESS:
			case DXGI_FORMAT_R32G32B32_FLOAT:
			case DXGI_FORMAT_R32G32B32_UINT:
			case DXGI_FORMAT_R32G32B32_SINT:
				return 12;
			case DXGI_FORMAT_R16G16B16A16_TYPELESS:
			case DXGI_FORMAT_R16G16B16A16_FLOAT:
			case DXGI_FORMAT_R16G16B16A16_UNORM:
			case DXGI_FORMAT_R16G16B16A16_UINT:
			case DXGI_FORMAT_R16G16B16A16_SNORM:
			case DXGI_FORMAT_R16G16B16A16_SINT:
			case DXGI_FORMAT_R32G32_TYPELESS:
			case DXGI_FORMAT_R32G32_FLOAT:
			case DXGI_FORMAT_R32G32_UINT:
			case DXGI_FORMAT_R32G32_SINT:
			case DXGI_FORMAT_R32G8X24_TYPELESS:
			case DXGI_FORMAT_D32_FLOAT_S8X24_UINT:
			case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS:
			case DXGI_FORMAT_X32_TYPELESS_G8X24_UINT:
				return 8;
			case DXGI_FORMAT_R10G10B10A2_TYPELESS:
			case DXGI_FORMAT_R10G10B10A2_UNORM:
			case DXGI_FORMAT_R10G10B10A2_UINT:
			case DXGI_FORMAT_R11G11B10_FLOAT:
			case DXGI_FORMAT_R8G8B8A8_TYPELESS:
			case DXGI_FORMAT_R8G8B8A8_UNORM:
			case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
			case DXGI_FORMAT_R8G8B8A8_UINT:
			case DXGI_FORMAT_R8G8B8A8_SNORM:
			case DXGI_FORMAT_R8G8B8A8_SINT:
			case DXGI_FORMAT_R16G16_TYPELESS:
			case DXGI_FORMAT_R16G16_FLOAT:
			case DXGI_FORMAT_R16G16_UNORM:
			case DXGI_FORMAT_R16G16_UINT:
			case DXGI_FORMAT_R16G16_SNORM:
			case DXGI_FORMAT_R16G16_SINT:
			case DXGI_FORMAT_R32_TYPELESS:
			case DXGI_FORMAT_D32_FLOAT:
			case DXGI_FORMAT_R32_FLOAT:
			case DXGI_FORMAT_R32_UINT:
			case DXGI_FORMAT_R32_SINT:
			case DXGI_FORMAT_R24G8_TYPELESS:
			case DXGI_FORMAT_D24_UNORM_S8_UINT:
			case DXGI_FORMAT_R24_UNORM_X8_TYPELESS:
			case DXGI_FORMAT_X24_TYPELESS_G8_UINT:
			case DXGI_FORMAT_R9G9B9E5_SHAREDEXP:
			case DXGI_FORMAT_B8G8R8A8_UNORM:
			case DXGI_FORMAT_B8G8R8X8_UNORM:
			case DXGI_FORMAT_B8G8R8A8_TYPELESS:
			case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
			case DXGI_FORMAT_B8G8R8X8_TYPELESS:
			case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
				return 4;
			case DXGI_FORMAT_R8G8_TYPELESS:
			case DXGI_FORMAT_R8G8_UNORM:
			case DXGI_FORMAT_R8G8_UINT:
			case DXGI_FORMAT_R8G8_SNORM:
			case DXGI_FORMAT_R8G8_SINT:
			case DXGI_FORMAT_R16_TYPELESS:
			case DXGI_FORMAT_R16_FLOAT:
			case DXGI_FORMAT_D16_UNORM:
			case DXGI_FORMAT_R16_UNORM:
			case DXGI_FORMAT_R16_UINT:
			case DXGI_FORMAT_R16_SNORM:
			case DXGI_FORMAT_R16_SINT:
			case DXGI_FORMAT_B5G6R5_UNORM:
			case DXGI_FORMAT_B5G5R5A1_UNORM:
				return 2;
			case DXGI_FORMAT_R8_TYPELESS:
			case DXGI_FORMAT_R8_UNORM:
			case DXGI_FORMAT_R8_UINT:
			case DXGI_FORMAT_R8_SNORM:
			case DXGI_FORMAT_R8_SINT:
			case DXGI_FORMAT_A8_UNORM:
				return 1;
			}
			return -1;
		}
	public:
		ID3D11ShaderResourceView* cubeResourceView;
		ISurface* getSurface(int id)
		{
			return &surfaces[id];
		}
		bool IsVideoTexture()
		{
			return false;
		}
		ITexture2D11(ID3D11Device* _device)
		{
			IsRenderTarget = 0;
			IsDepthTarget = 0;
			pDevice = _device;
			pDevice->GetImmediateContext(&context);
		}
		~ITexture2D11()
		{
			for(UINT i = 0; i<rtViews.size(); i++)
			{
				SAFE_DELETE(rtViews[i]);
			}
			for(UINT i = 0; i<srViews.size(); i++)
			{
				SAFE_DELETE(srViews[i]);
			}
			//SAFE_RELEASE(dsView); FIX ME
			rtViews.clear();
			srViews.clear();

			SAFE_RELEASE(texture);
		}
		std::vector<IRenderTargetView11*> rtViews;
		std::vector<IShaderResourceView11*> srViews;
		std::vector<ID3D11DepthStencilView*> dsViews;

		ID3D11Texture2D* texture;
		ID3D11Device* pDevice;
		ID3D11DeviceContext* context;
		LifeCore::IDataRectangle rectangle;
		D3D11_MAPPED_SUBRESOURCE mappedData;
		int t_width, t_height;
		int IsRenderTarget;
		int IsDepthTarget;

		IShaderResourceView* getSRView()
		{
			return srViews[0];
		}

		IShaderResourceView* getSRView(int index)
		{
			return srViews[index];
		}

		ID3D11DepthStencilView* getDSView()
		{
			return dsViews[0];
		}

		ID3D11DepthStencilView* getDSView(int index)
		{
			return dsViews[index];
		}

		IRenderTargetView* getRTView()
		{
			return rtViews[0];
		}

		IRenderTargetView* getRTView(int index)
		{
			return rtViews[index];
		}

		void addRenderTargetView(IRenderTargetView11* view)
		{
			rtViews.push_back(view);
			surfaces[rtViews.size() - 1].setRTV(view->view);
		}

		void addDepthStencilView(ID3D11DepthStencilView* view)
		{
			dsViews.push_back(view);
			surfaces[dsViews.size() - 1].setDSV(view);
		}

		void addShaderResourceView(IShaderResourceView11* view)
		{
			srViews.push_back(view);
			surfaces[srViews.size() - 1].setSRV(view->view);
		}

		void FromTexture(ID3D11Texture2D* tex)
		{
			if (tex)
			{
				texture = tex;

				D3D11_TEXTURE2D_DESC desc;
				texture->GetDesc(&desc);

				t_width = desc.Width;
				t_height = desc.Height;

				bpp = FormatToSize(desc.Format);

				this->Description.Width = desc.Width;
				this->Description.Height = desc.Height;
				this->Description.SampleCount = desc.SampleDesc.Count;
				this->Description.SampleQuality = desc.SampleDesc.Quality;
				this->Description.Format = desc.Format;
			}
		}
		ID3D11Texture2D* GetData()
		{
			return texture;
		}

		LifeCore::IDataRectangle* Map(int level, int read, int write)
		{
			D3D11_MAP flags = D3D11_MAP_WRITE_DISCARD;

			if(!read && !write)
				throw "ff";

			if(read && !write)
				flags = D3D11_MAP_READ;
			else if(!read && write)
				flags = D3D11_MAP_WRITE_DISCARD;
			else if (read && write)
				flags = D3D11_MAP_READ_WRITE;

			context->Map(texture, level, flags,0, &mappedData);

			rectangle.pitch = mappedData.RowPitch;
			rectangle.data.Reset((char*)mappedData.pData, t_width * t_height * bpp);

			return &rectangle;

			// return new LifeCore::IDataRectangle(stm.RowPitch, stm.Data.DataPointer);
		}
		void Unmap(int level)
		{
			context->Unmap(texture, level);
			//  g_textureData.Device.ImmediateContext.UnmapSubresource(g_textureData, 0);

			//g_textureData.AsSurface().Unmap();
		}

		int Width()
		{
			return t_width;
		}

		int Height()
		{
			return t_height;
		}

		void ToFile(const String& path)
		{
			D3DX11SaveTextureToFile(context,texture, D3DX11_IFF_DDS, path.c_str());
			LifeCore::CLog::me()->Write(AS_STRING("OH SHIIIT!!!  Texture saving!"));
			//Logger.Instance.Write("WARNING! Saving render target to file!" + "\n" + path);
			//Texture2D.ToFile((this.g_parent as RendererDX11).GetDeviceContext(), g_textureData,ImageFileFormat.Jpg,  path );
		}
		void CompleteAsyncRequest(IResource* source)
		{
			//Core::CLog::me()->Write(String(_text("CompleteAsyncRequest called in texture2D!")) + source->Name);
			//Texture2D11 src = (Texture2D11)source;
			// this.FromTexture(src.g_textureData);
		}

		void Load(LifeCore::IDataStreamPtr source)
		{
			ID3D11Resource* tex = 0;
			char* dataBuffer = new char[source->Length()];
			source->Read(dataBuffer, source->Length());
			HRESULT result = 0;
			D3DX11_IMAGE_LOAD_INFO info;

			info.Width = D3DX11_DEFAULT;
			info.Height = D3DX11_DEFAULT;
			info.Depth = D3DX11_DEFAULT;
			info.FirstMipLevel = 0;
			info.MipLevels = 6;
			info.Usage = (D3D11_USAGE) D3DX11_DEFAULT;
			info.BindFlags = D3DX11_DEFAULT;
			info.CpuAccessFlags = D3DX11_DEFAULT;
			info.MiscFlags = D3DX11_DEFAULT;
			info.Format = DXGI_FORMAT_FROM_FILE;
			info.Filter = D3DX11_FILTER_TRIANGLE;
			info.MipFilter = D3DX11_FILTER_TRIANGLE;
			info.pSrcInfo = NULL;

			result = D3DX11CreateTextureFromMemory(pDevice, dataBuffer,source->Length(),&info, 0, &tex, 0);
			delete[] dataBuffer;
			if(result == S_OK)
				FromTexture((ID3D11Texture2D*) tex);
			else
				LifeCore::CLog::me()->Write(String(_text("Can not load texture!")));
		}

	private:
		ISurface11 surfaces[6];
		/*  virtual int Width();
		virtual int Height();
		virtual LifeCore::IDataRectangle* Map(int level, bool read, bool write, int bpp) = 0;
		virtual void Unmap(int level) = 0;
		virtual void ToFile(const String& path) = 0;
		virtual void Load(const Core::IDataStream* src) {}
		virtual void CompleteAsyncRequest(IResource* source) {}*/
	};
}

#endif