#ifndef _NODE_H
#define _NODE_H

#include<stdint.h>
#include<stddef.h>
#include<stdbool.h>

#include<pthread.h>

#include"defs.h"

#include"bs.h"

#ifdef __cplusplus
extern "C" {
#endif

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
#define CUTIHI_T(a, b) ((((uint64_t) __builtin_bswap32(b)) << 32) | __builtin_bswap32(a))
#else
#define CUTIHI_T(a, b) ((((uint64_t) b) << 32) | a
#endif

typedef size_t(*CHiSaveWriter)(void *ud, const void *data, size_t len);
typedef size_t(*CHiLoadReader)(void *ud, void *data, size_t len);

typedef enum {
	CUTIHI_VAL_NONE = 0,
	CUTIHI_VAL_LINKED = 1,
	CUTIHI_VAL_KEYED = 2,
	CUTIHI_VAL_SAMPLE = 3,
	CUTIHI_VAL_TEXT = 4,
	CUTIHI_VAL_VEC4 = 5,
	CUTIHI_VAL_WEAK_PTR = 6,
	
	CUTIHI_VAL_VP8BS = 666,
	CUTIHI_VAL_VP9BS = 667,
	CUTIHI_VAL_OPUSBS = 668,
	CUTIHI_VAL_H264BS = 669,
	CUTIHI_VAL_AACBS = 670,
} CHiValType;

struct CHiImage;

struct CHiPubNode;

struct CHiKeyframes;

typedef union {
	struct {
		struct CHiPubNode *to;
		uint8_t idx;
	} linked;
	struct CHiImage *sample;
	char *text;
	float vec4[4];
	CHiBSFrames *bitstream;
	struct CHiKeyframes* keyed;
	uintptr_t weakptr;
} CHiValueRaw;

typedef struct {
	CHiValType type;
	CHiValueRaw data;
} CHiValue;

#define CUTIHI_ERR_SIZE 16
#define CUTIHI_MAX_ERRORS 4
typedef struct {
	bool activeLast[CUTIHI_MAX_ERRORS];
	bool active[CUTIHI_MAX_ERRORS];
	char code[CUTIHI_MAX_ERRORS][CUTIHI_ERR_SIZE];
	int sink[CUTIHI_MAX_ERRORS];
} CHiErrors;

typedef struct CHiPubNode {
	uint64_t type;
	
	uint32_t flags;
	
#define CUTIHI_PERFORM_UPDATED 1
#define CUTIHI_PERFORM_NOTUPDATED 0
	int (*Perform)(struct CHiPubNode *node);
	int (*Start)(struct CHiPubNode *node);
	int (*Stop)(struct CHiPubNode *node);
	
	void (*Destroy)(struct CHiPubNode *node);
	
	int (*Save)(struct CHiPubNode *node, void *ud, CHiSaveWriter writer);
	
	size_t sinkCount;
	CHiValue *sinks;
	
	size_t sourceCount;
	CHiValue *sources;
	
	struct CHiNodeGraph *ng;
	
	CHiErrors errors;
	
	struct {
		float start;
		float end;
	} lifespan;
	
	char _dfsmark;
} CHiPubNode;

typedef enum {
	CUTIHI_COMP_READY,
	CUTIHI_COMP_RUNNING,
	CUTIHI_COMP_KILL_YOURSELF
} CHiCompilationStatus;

typedef CHiPubNode *CHiAdjacency[2];

typedef enum {
	CUTIHI_EXTRAPOLATION_NONE = 0, CUTIHI_EXTRAPOLATION_CONSTANT = 1
} CHiExtrapolationMode;

typedef struct CHiKeyframes {
	CHiValType type;
	
	size_t count;
	
	float *times;
	CHiValueRaw *values;
	
	CHiValue current;
	
	CHiPubNode *node;
	
	CHiExtrapolationMode extrapolationMode;
	float extrapolationParameter[4];
} CHiKeyframes;

typedef struct CHiKeyframesList {
	size_t count;
	CHiKeyframes **keyframes;
} CHiKeyframesList;

typedef struct CHiNodeGraph {
	size_t capacity;
	size_t count;
	CHiPubNode **nodes;
	
	float duration;
	
	void *ud;
	void(*eventOnStopComplete)(struct CHiNodeGraph*);
	void(*eventOnFrameComplete)(struct CHiNodeGraph*);
	void(*eventOnError)(struct CHiNodeGraph*, CHiPubNode*);
	
	CHiCompilationStatus compilationStatus;
	
	size_t adjacencyCount, adjacencyCapacity;
	CHiAdjacency *adjacencies;
	
	CHiKeyframesList keyframesList;
	
	float time;
	float timedelta;
	
	// This is necessary for live changes of the node graph
	pthread_mutex_t mut;
} CHiNodeGraph;

CUTIVIS CHiNodeGraph *CHi_NewNodeGraph();
CUTIVIS CHiNodeGraph *CHi_NodeGraphReset(CHiNodeGraph *ng);
CUTIVIS int CHi_NodeGraphSave(CHiNodeGraph *ng, CHiSaveWriter writer, void *ud);
CUTIVIS int CHi_NodeGraphLoad(CHiNodeGraph *ng, CHiLoadReader reader, void *ud);

CUTIVIS void CHi_RegisterNode(CHiNodeGraph*, CHiPubNode*);
CUTIVIS void CHi_MakeDirty(CHiNodeGraph*, CHiPubNode*);
CUTIVIS int CHi_ConfigureSink(CHiPubNode*, size_t, CHiValue);

CUTIVIS void CHi_MakeKeyframe(CHiNodeGraph *ng, CHiPubNode *n, size_t idx);
CUTIVIS size_t CHi_MoveKeyframe(CHiNodeGraph *ng, CHiKeyframes *kfs, size_t idx, float to);
CUTIVIS size_t CHi_MoveKeyframeBy(CHiNodeGraph *ng, CHiKeyframes *kfs, size_t idx, float dt);
CUTIVIS size_t CHi_GetClosestKeyframe(CHiNodeGraph *ng, CHiKeyframes *kfs, float t);
CUTIVIS void CHi_SetExtrapolationMode(CHiNodeGraph *ng, CHiPubNode *n, size_t sinkIdx, CHiExtrapolationMode mode, float* params);
CUTIVIS void CHi_DeleteKeyframe(CHiNodeGraph *ng, CHiKeyframes *kfs, size_t idx);

CUTIVIS int CHi_Hysteresis(CHiPubNode*);

CUTIVIS void CHi_SetDuration(CHiNodeGraph *ng, float);
CUTIVIS void CHi_BeginCompilation(CHiNodeGraph *ng);
CUTIVIS void CHi_StopCompilation(CHiNodeGraph *ng);

#define CUTIHI_IMAGE_IN_FILE 0
#define CUTIHI_IMAGE_OUT_SAMPLE 0
CUTIVIS CHiPubNode *CHi_Image();

#define CUTIHI_EMBED_OUT_MAIN 0
#define CUTIHI_EMBED_MAX_SMALLS 3
CUTIVIS CHiPubNode *CHi_Embed();

#define CUTIHI_CONSTANTSAMPLE_IN_COLOR 0
#define CUTIHI_CONSTANTSAMPLE_IN_SIZE 1
#define CUTIHI_CONSTANTSAMPLE_OUT_SAMPLE 1
CUTIVIS CHiPubNode *CHi_ConstantSample();

#define CUTIHI_MODULATE_IN_SAMPLE 0
#define CUTIHI_MODULATE_BRIGHTNESS 1
#define CUTIHI_MODULATE_CONTAST 2
#define CUTIHI_MODULATE_HUE 3
#define CUTIHI_MODULATE_OUT_SAMPLE 4
CUTIVIS CHiPubNode *CHi_Modulate();

#define CUTIHI_MOVIE_IN_FILE 0
#define CUTIHI_MOVIE_IN_TIME 1
#define CUTIHI_MOVIE_IN_DELAY 2
#define CUTIHI_MOVIE_OUT_SAMPLE 2
CUTIVIS CHiPubNode *CHi_Movie();

#define CUTIHI_TIME_OUT 0
CUTIVIS void CHi_Time_Set(CHiNodeGraph *ng, float);
CUTIVIS float CHi_Time_Get(CHiNodeGraph *ng);
CUTIVIS float CHi_Time_GetDelta(CHiNodeGraph *ng);
CUTIVIS CHiPubNode *CHi_Time();

#define CUTIHI_ENCODEVP9_IN_SAMPLE 0
#define CUTIHI_ENCODEVP9_IN_BITRATE 1
#define CUTIHI_ENCODEVP9_IN_BITRATE 1
#define CUTIHI_ENCODEVP9_OUT_BITSTREAM 0
#define CUTIHI_NODE_ENCODEVP8 17
CUTIVIS CHiPubNode *CHi_EncodeVP9();
CUTIVIS CHiPubNode *CHi_EncodeVP8();
CUTIVIS int CHi_EncodeVP9_Start(CHiPubNode*);
CUTIVIS int CHi_EncodeVP9_Stop(CHiPubNode*);

#define CUTIHI_MUXWEBM_IN_BITSTREAM 0
#define CUTIHI_MUXWEBM_IN_AUDIOBITSTREAM 1
#define CUTIHI_MUXWEBM_IN_FILENAME 2
CUTIVIS CHiPubNode *CHi_MuxWebm();
CUTIVIS int CHi_MuxWebm_Start(CHiPubNode*);
CUTIVIS int CHi_MuxWebm_Stop(CHiPubNode*);

#define CUTIHI_WINDOW_IN_WINDOWNAME 0
#define CUTIHI_WINDOW_OUT_SAMPLE 1
CUTIVIS CHiPubNode *CHi_Window();

CUTIVIS size_t CHi_Window_GetSourceCount();
CUTIVIS const char *CHi_Window_GetSourceName(size_t);
CUTIVIS uintptr_t CHi_Window_GetSourceData(size_t);
CUTIVIS size_t CHi_Window_GetNextSource(size_t);

#define CUTIHI_MICROPHONE_IN_NAME 0
#define CUTIHI_MICROPHONE_OUT_AUDIO 1
CUTIVIS CHiPubNode *CHi_Microphone();

#define CUTIHI_TEXT_IN_TEXT 0
#define CUTIHI_TEXT_OUT_SAMPLE 0
CUTIVIS CHiPubNode *CHi_Text();

CUTIVIS CHiPubNode *CHi_ExportWav();

CUTIVIS CHiPubNode *CHi_EncodeOpus();

CUTIVIS CHiPubNode *CHi_Camera();

CUTIVIS CHiPubNode *CHi_Preview();

CUTIVIS CHiPubNode *CHi_ComponentScale();

CUTIVIS CHiPubNode *CHi_Keyhook();

CUTIVIS CHiPubNode *CHi_Mixer();

CUTIVIS CHiPubNode *CHi_ChromaKey();

CUTIVIS CHiPubNode *CHi_EncodeH264();

CUTIVIS CHiPubNode *CHi_StreamRTMP();

CUTIVIS CHiPubNode *CHi_EncodeAAC();

CUTIVIS CHiValue *CHi_Crawl(CHiValue*);

//CUTIVIS void CHi_Save(CHiNodeGraph *ng);

CUTIVIS bool CHi_Node_Active(CHiPubNode*);

#ifdef __cplusplus
}
#endif

#endif