#ifndef ASSETS_H
#define ASSETS_H

#include "animparts.h"
#include "model.h"
#include "material.h"
#include "materialpixelshader.h"
#include "materialtechset.h"
#include "gfximage.h"
#include "soundalias.h"
#include "soundcurve.h"
#include "loadedsound.h"
#include "clipmap.h"
#include "comworld.h"
#include "gameworld.h"
#include "mapent.h"
#include "gfxworld.h"
#include "gfxlightdef.h"
#include "gfximage.h"
#include "font.h"
#include "menulist.h"
#include "menudef.h"
#include "localizeentry.h"
#include "weapondef.h"
#include "sounddriver.h"
#include "effectdef.h"
#include "effecttable.h"
#include "rawfile.h"
#include "stringtable.h"

#include <QDebug>
#include <QObject>

struct AssetMap {
    QVector<std::shared_ptr<Animation>> animations;
    QVector<std::shared_ptr<Model>> models;
    QVector<std::shared_ptr<Material>> materials;
    QVector<std::shared_ptr<MaterialPixelShader>> pixelShaders;
    QVector<std::shared_ptr<MaterialTechSet>> techSets;
    QVector<std::shared_ptr<GfxWorld>> gfxWorlds;
    QVector<std::shared_ptr<GfxLightDef>> gfxLightDefs;
    QVector<std::shared_ptr<GfxImage>> images;
    QVector<std::shared_ptr<SoundAliasList>> sounds;
    QVector<std::shared_ptr<SoundCurve>> soundCurves;
    QVector<std::shared_ptr<LoadedSound>> loadedSounds;
    QVector<std::shared_ptr<ClipMap>> clipMaps;
    QVector<std::shared_ptr<ComWorld>> comWorlds;
    QVector<std::shared_ptr<GameWorldSp>> gameWorldSPs;
    QVector<std::shared_ptr<GameWorldMp>> gameWorldMPs;
    QVector<std::shared_ptr<MapEnts>> mapEntities;
    QVector<std::shared_ptr<GameFont>> fonts;
    QVector<std::shared_ptr<MenuList>> menuLists;
    QVector<std::shared_ptr<MenuDef>> menuDefinitions;
    QVector<std::shared_ptr<LocalizeEntry>> localizeEntries;
    QVector<std::shared_ptr<WeaponDef>> weaponDefinitions;
    QVector<std::shared_ptr<SoundDriver>> soundDrivers;
    QVector<std::shared_ptr<EffectDef>> effectDefinitions;
    QVector<std::shared_ptr<ImpactTable>> impactTables;
    QVector<std::shared_ptr<RawFile>> rawFiles;
    QVector<std::shared_ptr<StringTable>> stringTables;
};

class Assets : public QObject
{
    Q_OBJECT
public:
    AssetMap assetMap;

    Assets();
    ~Assets();
    Assets(const Assets &Assets);
    Assets &operator=(const Assets &other);

    virtual std::shared_ptr<Animation> Load_Animation(QDataStream *aZoneFileStream) {
        Animation result = {};

        // Load_XAnimPartsPtr()
        qint32 animationptr;
        *aZoneFileStream >> animationptr;

        if (animationptr) {
            if (animationptr != -1 && animationptr != -2) {
                return nullptr;
            }

            // Load_XAnimParts()
            XAnimParts animParts;
            *aZoneFileStream >> animParts;
        }

        return std::make_shared<Animation>(result);
    }
    virtual QString Load_XString(QDataStream *aZoneFileStream) {
        QString currentStr;

        qint32 stringPtr;
        *aZoneFileStream >> stringPtr;

        if (stringPtr) {
            if (stringPtr == -1) {
                currentStr = Load_XStringCustom(aZoneFileStream);
            }
            else {
                // Resolve from g_streamBlocks
            }
        }
        return currentStr;
    }
    virtual QString Load_XStringCustom(QDataStream *aZoneFileStream) {
        QString currentStr;
        char currentChar;
        *aZoneFileStream >> currentChar;
        while (currentChar != 0) {
            currentStr += currentChar;
            *aZoneFileStream >> currentChar;
        }
        return currentStr;
    }
    virtual std::shared_ptr<Model> Load_Model(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<Material> Load_Material(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<MaterialPixelShader> Load_MaterialPixelShader(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<MaterialTechSet> Load_MaterialTechSet(QDataStream *aZoneFileStream) {
        MaterialTechSet result = {};

        // Load_MaterialTechSetPtr()
        qint32 techSetPtr;
        *aZoneFileStream >> techSetPtr;

        if (techSetPtr) {
            if (techSetPtr != -1 && techSetPtr != -2) {
                return nullptr;
            }

            // Load_MaterialTechSet()
            QByteArray varMaterialTechniqueSet(116, Qt::Uninitialized);
            aZoneFileStream->readRawData(varMaterialTechniqueSet.data(), 116);

            aZoneFileStream->skipRawData(4);

            result.name = Load_XString(aZoneFileStream);

            result.techniques = Load_MaterialTechniquePtrArray(aZoneFileStream, 26);
        }

        return std::make_shared<MaterialTechSet>(result);
    }
    virtual std::shared_ptr<GfxImage> Load_GfxImage(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<SoundAliasList> Load_SoundAliasList(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<SoundCurve> Load_SoundCurve(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<LoadedSound> Load_LoadedSound(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<ClipMap> Load_ClipMap(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<ComWorld> Load_ComWorld(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<GameWorldSp> Load_GameWorldSp(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<GameWorldMp> Load_GameWorldMp(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<MapEnts> Load_MapEnts(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<GfxWorld> Load_GfxWorld(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<GfxLightDef> Load_GfxLightPtr(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<GameFont> Load_GameFont(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<MenuList> Load_MenuList(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<MenuDef> Load_MenuDef(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<LocalizeEntry> Load_LocalizeEntry(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<WeaponDef> Load_WeaponDef(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<SoundDriver> Load_SoundDriver(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<EffectDef> Load_EffectDef(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<ImpactTable> Load_ImpactTable(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<RawFile> Load_RawFile(QDataStream *aZoneFileStream) = 0;
    virtual std::shared_ptr<StringTable> Load_StringTable(QDataStream *aZoneFileStream) = 0;

    virtual QVector<std::shared_ptr<MaterialTechnique>> Load_MaterialTechniquePtrArray(QDataStream *aZoneFileStream, int count) {
        QVector<std::shared_ptr<MaterialTechnique>> result;

        for (int i = 0; i < count; i++) {
            qint32 materialTechniquePtr;
            *aZoneFileStream >> materialTechniquePtr;
            if (materialTechniquePtr) {
                if (materialTechniquePtr == -1) {
                    result << Load_MaterialTechnique(aZoneFileStream);
                }
            }
        }
        return result;
    }

virtual std::shared_ptr<MaterialTechnique> Load_MaterialTechnique(QDataStream *aZoneFileStream) {
    int passCount;
    qDebug() << "D3DResource size: " << sizeof(D3DResource);
    return nullptr;

}

virtual std::shared_ptr<MaterialPass> Load_MaterialPassArray(QDataStream *aZoneFileStream) {
    return nullptr;
}

private slots:

private:
};

#endif // ASSETS_H