#include <utility>


#ifndef PORYGONLANG_SCRIPTTYPE_HPP
#define PORYGONLANG_SCRIPTTYPE_HPP

#include <utility>
#include <vector>
#include <memory>
#include "Binder/BoundVariables/BoundVariableKey.hpp"
#include "Utilities/HashedString.hpp"

using namespace std;

enum class TypeClass{
    Error,
    Nil,
    Number,
    Bool,
    String,
    Function,
    UserData,
    Table,
};

class ScriptType{
    TypeClass _class;
public:
    explicit ScriptType(TypeClass c){
        _class = c;
    }

    virtual ~ScriptType() = default;

    const TypeClass GetClass() const{
        return _class;
    }

    virtual bool operator ==(const ScriptType& b) const{
        return _class == b._class;
    };

    virtual bool operator ==(ScriptType* b) const{
        return _class == b->_class;
    };

    virtual bool operator !=(const ScriptType& b) const{
        return ! (operator==(b));
    }
    virtual bool operator !=(ScriptType* b) const{
        return ! (operator==(b));
    }

    virtual const bool CanBeIndexedWith(ScriptType* indexer) const;
    virtual const bool CanBeIndexedWithIdentifier(uint32_t hash) const{
        return false;
    }

    virtual const shared_ptr<ScriptType> GetIndexedType(ScriptType* indexer) const;
    virtual const shared_ptr<ScriptType> GetIndexedType(uint32_t hash) const{
        throw "Shouldn't be possible";
    }
};

class NumericScriptType : public ScriptType{
    // Are we aware of whether this is a float or not?
    bool _awareOfFloat;
    // Is this value a float?
    bool _isFloat;
public:
    explicit NumericScriptType(bool floatAware, bool isFloat) : ScriptType(TypeClass::Number){
        _awareOfFloat = floatAware;
        _isFloat = isFloat;
    }

    const bool IsAwareOfFloat() const{
        return _awareOfFloat;
    }

    const bool IsFloat() const{
        return _isFloat;
    }
};

class StringScriptType : public ScriptType{
    bool _isKnownAtBind;
    uint32_t _hashValue;
public:
    explicit StringScriptType(bool knownAtBind, uint32_t hashValue): ScriptType(TypeClass::String){
        _isKnownAtBind = knownAtBind;
        _hashValue = hashValue;
    }

    const bool IsKnownAtBind() const{
        return _isKnownAtBind;
    }

    const uint32_t GetHashValue() const{
        return _hashValue;
    }
};

class FunctionScriptType : public ScriptType{
    shared_ptr<ScriptType> _returnType;
    vector<shared_ptr<ScriptType>> _parameterTypes;
    vector<shared_ptr<BoundVariableKey>> _parameterKeys;
    int _scopeIndex;
public:
    FunctionScriptType(std::shared_ptr<ScriptType> returnType, vector<shared_ptr<ScriptType>> parameterTypes,
            vector<shared_ptr<BoundVariableKey>> parameterKeys, int scopeIndex)
    : ScriptType(TypeClass::Function){
        _returnType = std::move(returnType);
        _parameterTypes = std::move(parameterTypes);
        _parameterKeys = std::move(parameterKeys);
        _scopeIndex = scopeIndex;
    }
    const shared_ptr<ScriptType> GetReturnType() const{
        return _returnType;
    }

    void SetReturnType(shared_ptr<ScriptType> t){
        _returnType = std::move(t);
    }

    const vector<shared_ptr<ScriptType>> GetParameterTypes() const{
        return _parameterTypes;
    }

    const vector<shared_ptr<BoundVariableKey>> GetParameterKeys() const{
        return _parameterKeys;
    }

    const int GetScopeIndex() const{
        return _scopeIndex;
    }
};

class NumericalTableScriptType : public ScriptType{
    shared_ptr<ScriptType> _valueType;
    // Consider adding a check whether the table actually contains a type if every key is static.
public:
    explicit NumericalTableScriptType(shared_ptr<ScriptType> valueType) : ScriptType(TypeClass::Table){
        _valueType = std::move(valueType);
    }

    const bool CanBeIndexedWith(ScriptType* indexer) const final{
        return indexer->GetClass() == TypeClass ::Number;
    }

    const shared_ptr<ScriptType> GetIndexedType(ScriptType* indexer) const final{
        return _valueType;
    }
};


#endif //PORYGONLANG_SCRIPTTYPE_HPP