1/* Copyright Statement:
2 *
3 * (C) 2021-2025  Cubios Inc. All rights reserved.
4 */
5#pragma once
6 
7#include "Scene.h"
8#include "SceneObject.h"
9#include "Math/Rect2.h"
10 
11#include <string>
12#include <unordered_map>
13 
14namespace Cubios 
15{
16namespace Gfx
17{
18    class SpriteAtlasBase;
19    class SpriteAtlasElement: public Cubios::SceneObject
20    {
21        public: 
22            SpriteAtlasElement(SpriteAtlasBase* host, const Cubios::Math::Rect2& rc);
23            virtual ~SpriteAtlasElement();
24 
25            void Render() override;
26 
27            virtual SpriteAtlasElement* Copy();
28 
29	    inline Cubios::Math::Rect2* Rect() {return &this->rc;}
30        protected:
31            Cubios::Math::Rect2 rc;
32            SpriteAtlasBase* host;
33    };
34 
35    class SpriteAtlasBase
36    {
37        public:
38        SpriteAtlasBase(Cubios::Scene* scene): scene(scene) {}
39 
40        public: 
41            u32_t resourceId;
42            Cubios::Scene* scene;
43    };
44 
45    template <typename T>
46    class SpriteAtlas: public SpriteAtlasBase
47    {
48        static_assert(std::is_base_of<Cubios::Gfx::SpriteAtlasElement, T>::value, "T must inherit from Cubios::Gtf::SpriteAtlasElement");
49 
50        public: 
51            SpriteAtlas(std::string name, Cubios::Scene* scene);
52            virtual ~SpriteAtlas();
53 
54            bool AddSprite(uint32_t id, const Cubios::Math::Rect2& rc);
55            bool RemoveSprite(uint32_t id);
56 
57            T* operator[](uint32_t);
58            T* Get(uint32_t ind);
59 
60	    inline size_t Count() {return elements.size();}
61	    inline std::vector<uint32_t>* ElementsInsertionOrder() {return &this->insertion_order;}
62        private:
63            std::unordered_map<uint32_t,T*> elements;
64	    std::vector<uint32_t> insertion_order;
65    };
66}
67}
68 
69 
70namespace Cubios 
71{
72    namespace Gfx
73    {
74        template <typename T>
75        SpriteAtlas<T>::SpriteAtlas(std::string name, Cubios::Scene* scene):SpriteAtlasBase(scene)
76        {
77            this->resourceId = Cubios::GFX_getAssetId(name.c_str());
78        }
79 
80        template <typename T>
81        SpriteAtlas<T>::~SpriteAtlas()
82        {}
83 
84        template <typename T>
85        bool SpriteAtlas<T>::AddSprite(uint32_t id, const Cubios::Math::Rect2& rc)
86        {
87            bool ret = true;
88 
89            if(this->scene->CreateObjectWithID(id,new T(this,rc)))
90            {
91                this->elements[id] = dynamic_cast<T*>(this->scene->operator[](id));
92		this->insertion_order.push_back(id);	
93            }
94            else
95            {
96                 LOG_e("SpriteAtlas::AddSprite: Resource with id %d already exists\n",id);
97                 ret = false; 
98            }
99 
100            return ret;
101        }
102 
103        template <typename T>
104        bool SpriteAtlas<T>::RemoveSprite(uint32_t id)
105        {
106           bool ret = true;
107            typename std::unordered_map<uint32_t, T*>::iterator it = this->elements.find(id);
108 
109            if(it!=this->elements.end())
110            {
111                if(this->elements[id]!=nullptr)
112                {
113                    delete this->elements[id];
114                }
115 
116                this->elements.erase(it);
117 
118		std::vector<uint32_t>::iterator it2 = this->insertion_order.find(id);
119		if(it2!=this->insertion_order.end())
120		{
121		   this->insertion_order.erase(it2);
122		}
123            }
124            else
125            {
126                ret = false;
127            }
128 
129            return ret; 
130        }
131        
132        template <typename T>
133        T* SpriteAtlas<T>::operator[](uint32_t ind)
134        {
135            return this->elements[ind];
136        }
137 
138        template <typename T>
139        T* SpriteAtlas<T>::Get(uint32_t ind)
140        {
141            return this->elements[ind];
142        }
143    }
144}
145 
146