#ifndef RENDERER_H
#define RENDERER_H

#include "pch.hpp"

#include "extratools.h"

namespace Archimedes {


    class VertexArray {

        public:
            VertexArray(const void* data, size_t size) : data(data), size(size) {
            }
            
            ~VertexArray() {}

            const void* getData() const { return data; }
            size_t getSize() const { return size; }
            unsigned int getId() const { return id; }

        private:
            const void* data;
            size_t size;
            unsigned int id;
    };

    class IndexArray {

        public:
            IndexArray(const unsigned int* indices, size_t count) : indices(indices), count(count) {
            }
            
            ~IndexArray() {}

            const void* getIndicies() const { return indices; }
            size_t getCount() const { return count; }

        private:
            const unsigned int* indices;
            size_t count;
            unsigned int id;
    };

    class Shader {

        public:
            enum class LoadType {
                FromSource,
                FromFileSource,
                FromFileBin
            };

            Shader(const std::string& source, LoadType loadType) {
                switch(loadType) {
                    case LoadType::FromSource:
                        break;
                    case LoadType::FromFileSource:
                        break;
                    case LoadType::FromFileBin:
                        break;
                    default:
                        break;
                }
            }

            ~Shader() {}

            unsigned int getId() const { return id; }

        private:
            unsigned int id;
    };

    class RenderTarget {

        public:
            RenderTarget(const void* data, size_t size, size_t count, const std::string& shader) 
                : data(data), size(size), count(count), shader(shader) {}

            ~RenderTarget() {}

        private:
            const void* data;
            size_t size;
            size_t count;
            const std::string& shader;
    };

    class Renderer {

        public:
            int w, h;

            glm::vec4 clearColor = { 0.0f, 0.0f, 0.0f, 0.0f };
            
            Renderer() : w(0), h(0) {}

            virtual ~Renderer() {}

            virtual bool init() = 0;

            virtual void render() = 0;
            
            virtual void draw(const VertexArray&, const IndexArray&, const Shader&) = 0;

            virtual Renderer* getRendererImpl() = 0;

    };
}

#endif