#include <stddef.h>
#include <wren.h>
#include <raylib.h>

#ifndef PUZZLE_H
#define PUZZLE_H

/// The amount of seconds granted is calculated as (test_count * uniq(test_signatures).length) * DIFF_MODIFIER
static const size_t DIFF_MODIFIER = 30;

// This is a param that would be placed in a slot
// https://wren.io/embedding/slots-and-handles.html#writing-slots
typedef struct {
    WrenType type;
    // We store this value as void * to generalize. The downside of this approach
    // is an extencive allocation
    void *value;
} PuzzleIO;

// Represents a WREN_TYPE_LIST in PuzzleIO
typedef struct {
    size_t length;
    PuzzleIO *elements;
} PuzzleListIO;

typedef struct {
    // https://wren.io/embedding/calling-wren-from-c.html#setting-up-a-receiver
    char *RecieverName;
    // https://wren.io/embedding/calling-wren-from-c.html#getting-a-method-handle
    char *MainMethodSignature;

    size_t argc;
    PuzzleIO *argv;
    PuzzleIO ExpectedResult;
} Test;

enum PUZZLE_TEST_RESULT {
    RESULT_OK = 0,
    RESULT_WRONG_ANSWER,
    RESULT_COMPTIME_NO_ENTRY,
    RESULT_COMPTIME_ERR,
    RESULT_RUNTIME_ERR,
    RESULT_TIMEOUT,
    RESULT_INIT_ERROR,
};

typedef struct {
    enum PUZZLE_TEST_RESULT res;
    char *message;
} TestResult;

/// The user submitted code should be evaluated by this point. 
/// The entry point should be registered and the absence of the 
/// Main method signatire will be concidered an error
TestResult RunTest(Test *test, WrenVM *vm, size_t max_op);

typedef struct {
    char *Name;
    char *Description;
    char *InitialCode;

    /// The tests that are accessible for an end user
    size_t TestC;
    Test *Tests;
} Puzzle;
    
/// A prebuilt puzzle. Used for debuging
Puzzle *GetTestPuzzle();
Puzzle *ReadPuzzleFromFile(const char *path);

typedef struct {
    char *stdout_sb;
    enum PUZZLE_TEST_RESULT result;
} SubmitionResult;

/// Don't put anything in out_res, it will be overriten.
/// The stdout of the VM will be there
SubmitionResult *SubmitSolution(Puzzle *self, char *script);

void PrintPuzzle(Puzzle *puzzle);

void FreeSunmitionResult(SubmitionResult *res);
void FreePuzzle(Puzzle *self);


/// The puzzle that will pop up every now and then
typedef struct {
    Puzzle *puzzle;
    /// Seconds granted by the puzzle completion
    size_t SecondsGranted;
} DistractionPuzzle;

DistractionPuzzle *GetRandomDistraction();
void FreeDistrationPuzzle(DistractionPuzzle *puzzle);

typedef enum {
    COLLECTION_ELEMENT_PUZZLE,
    COLLECTION_ELEMENT_COLLECTION,
    COLLECTION_ELEMENT_UNKNOWN
} CollectionElementType;

typedef struct CollectionElement {
    char *path;
    char *name;
    struct CollectionElement *children;
    size_t childCount;
    Texture2D *icon;
    bool IsInitialized;
    CollectionElementType type;
} CollectionElement;

void InitializeCollection(CollectionElement *el);
void DrawCollectionElement(CollectionElement *el, Rectangle rec);

#endif // PUZZLE_H