#ifndef INCLUDED_SCHED_TASK
#define INCLUDED_SCHED_TASK

#ifndef INCLUDED_BASE_H_
#  include "base.h"
#endif

#ifndef INCLUDED_SCHEDULER
#  include "Scheduler.h"
#endif

#ifndef INCLUDED_SCHED_TASK_BASE
#  include "SchedTaskBase.h"
#endif

#ifndef INCLUDED_LIST_DATA
#  include "ListData.h"
#endif

#ifndef INCLUDED_TASK_GROUP
#  include "TaskGroup.h"
#endif


class SchedTask : public SchedTaskBase {
public:
    /* constructor */
    SchedTask(void);
    ~SchedTask(void);

    BASE_NEW_DELETE(SchedTask);

    /* variables */

    // Task を実行するスケジューラ自身
    Scheduler *__scheduler;

    // 現在スケジューラが実行している TaskList と、このタスクに対応する Task
    TaskListPtr __list;
    TaskPtr __task;

    // read/write 用の ListData
    ListDataPtr __inListData;
    ListDataPtr __outListData;

    /**
     * read データ、write 用のバッファ
     * readbuf には タスク登録時に設定した入力データが入っている。
     * writebuf にデータを描き込んでおくと、
     * タスク登録時に設定した出力先に書き込む
     */
    void *__readbuf;
    void *__writebuf;

    // Task の、Tasklist での位置。(task = &list[cur_index-1])
    int __cur_index;

    // タスク内で生成されたタスクのグループ
    TaskGroup *__taskGroup;

    // このタスク内で生成されたタスクの数
    int __renew_flag;

    // このタスクが SPE 内で生成されたタスクか否か 1: Yes, 0: No
    int __flag_renewTask;

    // タスクがメインメモリ側で生成されたものか、
    // SPE で生成されたものかによって、データの扱いが変わってくる。
    // そのために if (__flag_renewTask) を連発するのはよくないので
    // 関数ポインタで持っておく
    void (SchedTask::*ex_init)(void);
    void (SchedTask::*ex_read)(void);
    void (SchedTask::*ex_exec)(void);
    void (SchedTask::*ex_write)(void);
    SchedTaskBase* (SchedTask::*ex_next)(void);
    
    /* functions */
    void __setRenew(void);
    void __init__(TaskListPtr _list, TaskPtr _task, int index,
		  ListDataPtr rbuf, ListDataPtr wbuf, Scheduler* sc);

    // override
    void read(void);
    void exec(void);
    void write(void);
    SchedTaskBase* next(Scheduler *, SchedTaskBase *);

    // ここをユーザが継承して
    // それぞれのタスクに対応した処理を記述する
    virtual int run(void* r, void *w) { return 0; }

    //---  System API ---
    SchedTask* get_nextTask(TaskListPtr list);
    
    /**
     * PPE で生成されたタスクに対する
     * __init__, read,exec,write,next の付属(?)処理
     */
    void ex_init_normal(void);
    void ex_read_normal(void);
    void ex_exec_normal(void);
    void ex_write_normal(void);
    SchedTaskBase* ex_next_normal(void);

    /**
     * SPE で生成されたタスクに対する
     * __inti__, ead,exec,write,next の付属(?)処理
     */
    void ex_init_renew(void);
    void ex_read_renew(void);
    void ex_exec_renew(void);
    void ex_write_renew(void);
    SchedTaskBase* ex_next_renew(void);


    //---  User API ---
    int get_cpuid(void);

    void* get_input(void *buff, int index);
    void* get_output(void *buff, int index);
    uint32 get_inputAddr(int index);
    uint32 get_outputAddr(int index);
    int get_inputSize(int index);
    int get_outputSize(int index);
    int get_param(int index);

    TaskPtr create_task(int cmd);
    void wait_task(TaskPtr waitTask);

    void* global_alloc(int id, int size);
    void* global_get(int id);
    void global_free(int id);

    void mainMem_alloc(int id, int size);
    void mainMem_wait(void);
    void* mainMem_get(int id);

    void *allocate(int size);

    void dma_load(void *buf, uint32 addr, uint32 size, uint32 mask);
    void dma_store(void *buf,uint32 addr, uint32 size, uint32 mask);
    void dma_wait(uint32 mask);

    class STaskManager {
    public:
	STaskManager(SchedTask *_t) {
	    outer = _t;
	}

	BASE_NEW_DELETE(STaskManager);

	SchedTask *outer;

	int get_cpuid(void) {
	    return outer->get_cpuid();
	}
	
	void* get_input(int index) {
	    return outer->get_input(outer->__readbuf, index);
	}

	void* get_output(int index) {
	    return outer->get_output(outer->__writebuf, index);
	}

	uint32 get_inputAddr(int index) {
	    return outer->get_inputAddr(index);
	}

	uint32 get_outputAddr(int index) {
	    return outer->get_outputAddr(index);
	}

	uint32 get_inputSize(int index) {
	    return outer->get_inputSize(index);
	}

	uint32 get_outputSize(int index) {
	    return outer->get_outputSize(index);
	}

	int get_param(int index) {
	    return outer->get_param(index);
	}

	TaskPtr create_task(int cmd) {
	    return outer->create_task(cmd);
	}

	void wait_task(TaskPtr waitTask) {
	    outer->wait_task(waitTask);
	}
	
	void* global_alloc(int id, int size) {
	    return outer->global_alloc(id, size);
	}

	void* global_get(int id) {
	    return outer->global_get(id);
	}

	void global_free(int id) {
	    outer->global_free(id);
	}

	void mainMem_alloc(int id, int size) {
	    outer->mainMem_alloc(id, size);
	}

	void mainMem_wait(void) {
	    outer->mainMem_wait();
	}

	void* mainMem_get(int id) {
	    return outer->mainMem_get(id);
	}

	void *allocate(int size) {
	    return outer->allocate(size);
	}

	void dma_load(void *buf, uint32 addr, uint32 size, uint32 mask) {
	    outer->dma_load(buf, addr, size, mask);
	}

	void dma_store(void *buf,uint32 addr, uint32 size, uint32 mask) {
	    outer->dma_store(buf, addr, size, mask);
	}

	void dma_wait(uint32 mask) {
	    outer->dma_wait(mask);
	}
    };

    STaskManager *smanager;
};

const int SCHED_TASK_NORMAL = 0;
const int SCHED_TASK_RENEW  = 1;

#endif

extern SchedTask* createSchedTask(TaskPtr);