#ifndef INCLUDED_VIEWER
#define INCLUDED_VIEWER

#include <SDL.h>

#include "viewer_types.h"
#include "TaskManager.h"
#include "KeyStat.h"
#include "MainLoop.h"
#include "Application.h"
#include "SceneGraphRoot.h"
#include "ViewerDevice.h"
#include "Light.h"

class SceneGraphRoot;

class Application;


class Viewer : public MainLoop {

public:
    Light *light;
/* measure for FPS (Frame Per Second) */
    int start_time;
    int this_time;
    int frames;

    typedef struct rendering_data {
        PolygonPack *ppack;
        SpanPackPtr spackList;
        SpanPackPtr *spackList_ptr;

        int spackList_length;
	int spackList_length_align;
    } RenderingData ;
    RenderingData r[2];

    int  ppi, spi;
    Viewer(){ profile = 0; ppi = spi = 0;};
    Viewer(TaskManager *manager, ViewerDevice *dev, int bpp, int width, int height, int spenum);

    virtual ~Viewer() {}
    BASE_NEW_DELETE(Viewer);

    ViewerDevice *dev;
    Application *app;

    TaskManager *manager;
    key_stat *keyPtr;
    HTaskPtr draw_dummy;

    /* screen info */
    int bpp;

    int rgb_size[3];
    int spe_num;
    int width;
    int height;

    float *light_xyz;
    float *light_xyz_stock;
    int *light_switch;
    int *light_switch_stock;
    int *light_sysswitch;
    int light_sysswitch_stock;

    Uint32 video_flags;
    Uint32 *pixels;

    int mem_flag;
    int profile;

    int pp_sum_num;

    SceneGraphRoot *sgroot;

    //Uint32 *video_init(TaskManager *manager, int bpp, int width, int height);
    void init();

    int get_ticks();
    bool quit_check();
    void quit();
    HTaskPtr initLoop();

    void clean_pixels() {}

    void run_init(TaskManager *manager, Application *app);
    bool main_exec(HTaskPtr task_next);
    void run_loop(HTaskPtr task_next);
    void run_draw(HTaskPtr task_next);
    virtual void run_finish();
    void run_move(HTaskPtr task_next);
    void run_collision();
    void create_pp(HTaskPtr task_next);
    void create_sp(HTaskPtr task_next);
    void common_draw(HTaskPtr task_next);
    void rendering_pp(HTaskPtr task_next, SceneGraphRoot *sgroot);
    void rendering_sp(HTaskPtr task_next, SceneGraphRoot *sgroot);
    void reinit_spackList() ;

    //void common_rendering(HTaskPtr task_next, SceneGraphRoot *sgroot);

    //  void exchange_sgroot(TaskManager *manager);

    HTaskPtr update_task_create(void *data, int size, 
				int load_id, int spe_id, HTaskPtr wait);

    void getKey();
    void get_send_controll();

    // void createFromXMLfile(const char *file);
    // SceneGraph *createSceneGraph(int id);
    // SceneGraph *createSceneGraph();
    // void setSceneData(SceneGraph *g);
    virtual void mainLoop();

    // In Application::init, SceneGraphRoot API is called bia viewer 
  
    void createStringFont(SceneGraphPtr root, const char *string, int pixels, int screen_w, int screen_h, Uint32 color)
    {
      sgroot -> createStringFont(manager, root, string, pixels, screen_w, screen_h, color);
    }
    void createFont(const char *font,int pixels,Uint32 color, const char *filename, int len, char **obj_name)
    {
      sgroot -> createFont(manager,font,pixels,color,filename, len, obj_name);
    }
    void task_array_init(int id, int task_num, int param, int inData_num, int outData_num)
    {
      sgroot->task_array_init(id, task_num, param, inData_num, outData_num);
    }
    void set_move_task(SceneGraphPtr node, int move, void *titlep, int size)
    {
      sgroot->set_move_task(node, move, titlep, size);
    }
    void set_pad_task(SceneGraphPtr node, int move, void *property, int size)
    {
      sgroot->set_pad_task(node, move, property, size);
    }

    void createFromXMLmemory(SceneGraph * node, char *data, int len)
    {
	sgroot->createFromXMLmemory(manager, node, data, len);
    }

    void createFromXMLfile(const char *file)
    {
	sgroot->createFromXMLfile(manager, file);
    }

    void createFromCOLLADAfile(const char *file)
    {
	sgroot->createFromCOLLADAfile(manager, file);
    }

    Pad * getController()
    {
      return sgroot->getController();
    }

    SceneGraph * createSceneGraph(int id)
    {
	return sgroot->createSceneGraph(id);
    }

    SceneGraph * createSceneGraph(const char *id)
    {
        return sgroot->createSceneGraph(id);
    }

    int getSgid(const char *id)
    {
	return sgroot->getSgid(id);
    }

    SceneGraph * createSceneGraph()
    {
	return sgroot->createSceneGraph();
    }

    void setSceneData(SceneGraph *g)
    {
	sgroot->setSceneData(g);
    }

    int getLast()
    {
	return sgroot->getLast();
    }

    SceneGraphPtr getLight(int id)
    {
      return sgroot->getLight(id);
    }

    CameraPtr getCamera()
    {
      return sgroot->getCamera();
    }


    void OnLightSwitch(int id)
    {
      sgroot->OnLightSwitch(id);
    }

    void OffLightSwitch(int id)
    {
      sgroot->OffLightSwitch(id);
    }

    void OnLightSysSwitch()
    {
      sgroot->OnLightSysSwitch();
    }

    void OffLightSysSwitch()
    {
      sgroot->OffLightSysSwitch();
    }

};

#define default_sdl_flag SDL_INIT_TIMER | SDL_INIT_JOYSTICK


#endif