/**
 * $Id$
 * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version. The Blender
 * Foundation also sells licenses for use in proprietary software under
 * the Blender License.  See http://www.blender.org/BL/ for information
 * about this.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 *
 * The Original Code is: all of this file.
 *
 * Contributor(s): none yet.
 *
 * ***** END GPL/BL DUAL LICENSE BLOCK *****
 */

/***************************************************************************

                          main.c  -  description
                             -------------------
    begin                : Fri Sep 15 19:19:43 CEST 2000
    copyright            : (C) 2000 by Jan Walter
    email                : jan@blender.nl
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

/* CVS */
/* $Author$ */
/* $Date$ */
/* $RCSfile$ */
/* $Revision$ */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdio.h>
#include <stdlib.h>

#include "Python.h"

static PyObject* ErrorObject;
static PyObject* _scene;

static PyObject* blend_connect(PyObject* self, PyObject* args);

/**************/
/* structures */
/**************/

typedef struct {
  PyObject_HEAD
  char name[24];
  PyObject* vertices;
  PyObject* normals;
  PyObject* faces;
} mshobject;

staticforward PyTypeObject Mshtype;

typedef struct {
  PyObject_HEAD
  char name[24];
  PyObject* matrix;
  PyObject* data;
  PyObject* type;
} objobject;

staticforward PyTypeObject Objtype;

typedef struct {
  PyObject_HEAD
  char name[24];
  PyObject* objects;
} sceobject;

staticforward PyTypeObject Scetype;

/********/
/* mesh */
/********/

static char msh_addFace__doc__[] =
"addFace(self, i1, i2, i3, i4, isSmooth)"
;

static PyObject*
msh_addFace(mshobject* self, PyObject* args)
{
  int index;
  int i1, i2, i3, i4;
  int isSmooth;
  PyObject *item = NULL;

  if (!PyArg_ParseTuple(args, "iiiii", &i1, &i2, &i3, &i4, &isSmooth))
    {
      return NULL;
    }
  item = PyList_New(5);
  PyList_SetItem(item, 0, PyInt_FromLong(i1));
  PyList_SetItem(item, 1, PyInt_FromLong(i2));
  PyList_SetItem(item, 2, PyInt_FromLong(i3));
  PyList_SetItem(item, 3, PyInt_FromLong(i4));
  PyList_SetItem(item, 4, PyInt_FromLong(isSmooth));
  PyList_Append(self->faces, item);
  index = PyList_Size(self->faces) - 1;

  return PyInt_FromLong(index);
}

static char msh_addVertex__doc__[] =
"addVertex(self, x, y, z, nx, ny, nz)"
;

static PyObject*
msh_addVertex(mshobject* self, PyObject* args)
{
  int   index;
  float x, y, z, nx, ny, nz;
  PyObject *item1 = NULL;
  PyObject *item2 = NULL;

  if (!PyArg_ParseTuple(args, "ffffff", &x, &y, &z, &nx, &ny, &nz))
    {
      return NULL;
    }
  item1 = PyList_New(3);
  item2 = PyList_New(3);
  PyList_SetItem(item1, 0, PyFloat_FromDouble(x));
  PyList_SetItem(item1, 1, PyFloat_FromDouble(y));
  PyList_SetItem(item1, 2, PyFloat_FromDouble(z));
  PyList_SetItem(item2, 0, PyFloat_FromDouble(nx));
  PyList_SetItem(item2, 1, PyFloat_FromDouble(ny));
  PyList_SetItem(item2, 2, PyFloat_FromDouble(nz));
  PyList_Append(self->vertices, item1);
  PyList_Append(self->normals, item2);
  index = PyList_Size(self->vertices) - 1;

  return PyInt_FromLong(index);
}

static struct PyMethodDef msh_methods[] = {
  {"addFace",   (PyCFunction)msh_addFace,
   METH_VARARGS, msh_addFace__doc__},
  {"addVertex", (PyCFunction)msh_addVertex,
   METH_VARARGS, msh_addVertex__doc__},

  { NULL, NULL }
};

static mshobject*
newmshobject(char* name)
{
  mshobject* self;

  self = PyObject_NEW(mshobject, &Mshtype);
  if (self == NULL)
    {
      return NULL;
    }
  strcpy(self->name, name);
  self->vertices = PyList_New(0);
  self->normals = PyList_New(0);
  self->faces = PyList_New(0);

  return self;
}

static void
msh_dealloc(mshobject* self)
{
  mshobject* msh = (mshobject*) self;

  Py_DECREF(msh->vertices);
  Py_DECREF(msh->normals);
  Py_DECREF(msh->faces);

  PyMem_DEL(self);
}

static int
msh_print(mshobject* self, FILE* fp, int flags)
{
  fprintf(fp, "Mesh(name = \"%s\",\n", self->name);
  fprintf(fp, "     vertices = %d,\n", PyList_Size(self->vertices));
  fprintf(fp, "     faces = %d)\n", PyList_Size(self->faces));

  return 0;
}

static PyObject*
msh_repr(mshobject* self)
{
  PyObject* s;

  s = PyString_FromString("Mesh()\n");

  return s;
}

static PyObject*
msh_str(mshobject* self)
{
  PyObject* s;

  s = PyString_FromString("Mesh()\n");

  return s;
}

#include "structmember.h"

static struct memberlist msh_memberlist[] = {
  /* XXXX Add lines like { "foo", T_INT, OFF(foo), RO }  */
  {"vertices", T_OBJECT, offsetof(mshobject, vertices), RO},
  {"normals", T_OBJECT, offsetof(mshobject, normals), RO},
  {"faces", T_OBJECT, offsetof(mshobject, faces), RO},
  {NULL}
};

static PyObject*
msh_getattr(mshobject* self, char* name)
{
  PyObject* rv;

  /* XXXX Add your own getattr code here */
  rv = PyMember_Get((char*) self, msh_memberlist, name);
  if (rv)
    {
      return rv;
    }
  PyErr_Clear();

  return Py_FindMethod(msh_methods, (PyObject*)self, name);
}


static int
msh_setattr(mshobject* self, char* name, PyObject* v)
{
  /* XXXX Add your own setattr code here */
  if ( v == NULL )
    {
      PyErr_SetString(PyExc_AttributeError, "Cannot delete attribute");
      return -1;
    }

  return PyMember_Set((char*)/*XXXX*/0, msh_memberlist, name, v);
}

static char Mshtype__doc__[] =
""
;

static PyTypeObject Mshtype = {
  PyObject_HEAD_INIT(&PyType_Type)
  0,				/*ob_size*/
  "Mesh",			/*tp_name*/
  sizeof(mshobject),	/*tp_basicsize*/
  0,				/*tp_itemsize*/
  /* methods */
  (destructor) msh_dealloc,	/*tp_dealloc*/
  (printfunc) msh_print,	/*tp_print*/
  (getattrfunc) msh_getattr,	/*tp_getattr*/
  (setattrfunc) msh_setattr,	/*tp_setattr*/
  (cmpfunc) 0,	/*tp_compare*/
  (reprfunc) msh_repr,		/*tp_repr*/
  0,		/*tp_as_number*/
  0,		/*tp_as_sequence*/
  0,		/*tp_as_mapping*/
  (hashfunc) 0,		/*tp_hash*/
  (ternaryfunc) 0,	/*tp_call*/
  (reprfunc) msh_str,		/*tp_str*/

  /* Space for future expansion */
  0L,0L,0L,0L,
  Mshtype__doc__ /* Documentation string */
};

/**********/
/* object */
/**********/

static struct PyMethodDef obj_methods[] = {

  { NULL, NULL }
};

static objobject*
newobjobject(char* name)
{
  objobject* self = NULL;
  PyObject*  row1 = NULL;
  PyObject*  row2 = NULL;
  PyObject*  row3 = NULL;
  PyObject*  row4 = NULL;

  self = PyObject_NEW(objobject, &Objtype);
  if (self == NULL)
    {
      return NULL;
    }
  strcpy(self->name, name);
  self->matrix = PyList_New(4);
  row1 = PyList_New(4);
  row2 = PyList_New(4);
  row3 = PyList_New(4);
  row4 = PyList_New(4);
  PyList_SetItem(row1, 0, PyInt_FromLong(1));
  PyList_SetItem(row1, 1, PyInt_FromLong(0));
  PyList_SetItem(row1, 2, PyInt_FromLong(0));
  PyList_SetItem(row1, 3, PyInt_FromLong(0));
  PyList_SetItem(row2, 0, PyInt_FromLong(0));
  PyList_SetItem(row2, 1, PyInt_FromLong(1));
  PyList_SetItem(row2, 2, PyInt_FromLong(0));
  PyList_SetItem(row2, 3, PyInt_FromLong(0));
  PyList_SetItem(row3, 0, PyInt_FromLong(0));
  PyList_SetItem(row3, 1, PyInt_FromLong(0));
  PyList_SetItem(row3, 2, PyInt_FromLong(1));
  PyList_SetItem(row3, 3, PyInt_FromLong(0));
  PyList_SetItem(row4, 0, PyInt_FromLong(0));
  PyList_SetItem(row4, 1, PyInt_FromLong(0));
  PyList_SetItem(row4, 2, PyInt_FromLong(0));
  PyList_SetItem(row4, 3, PyInt_FromLong(1));
  PyList_SetItem(self->matrix, 0, row1);
  PyList_SetItem(self->matrix, 1, row2);
  PyList_SetItem(self->matrix, 2, row3);
  PyList_SetItem(self->matrix, 3, row4);
  Py_INCREF(Py_None);
  self->data = Py_None;
  Py_INCREF(Py_None);
  self->type = Py_None;

  return self;
}

static void
obj_dealloc(objobject* self)
{
  objobject* obj = (objobject*) self;

  Py_DECREF(obj->matrix);
  Py_DECREF(obj->data);
  Py_DECREF(obj->type);

  PyMem_DEL(self);
}

static int
obj_print(objobject* self, FILE* fp, int flags)
{
  fprintf(fp, "Object(name = \"%s\",\n", self->name);
/*    fprintf(fp, "       matrix = %s,\n", */
/*  	  PyString_AsString(mtx_repr((mtxobject*) self->matrix))); */
  if (self->type == Py_None)
    {
      fprintf(fp, "       data = None)\n");
    }
  else
    {
      fprintf(fp, "       data = %s(\"%s\"))\n",
	      PyString_AsString(self->type),
	      ((mshobject*) self->data)->name);
    }

  return 0;
}

static PyObject*
obj_repr(objobject* self)
{
  PyObject* s;

  s = PyString_FromString("Object()\n");

  return s;
}

static PyObject*
obj_str(objobject* self)
{
  PyObject* s;

  s = PyString_FromString("Object()\n");

  return s;
}

#include "structmember.h"

static struct memberlist obj_memberlist[] = {
  /* XXXX Add lines like { "foo", T_INT, OFF(foo), RO }  */
  {"data",   T_OBJECT, offsetof(objobject, data), RO},
  {"matrix", T_OBJECT, offsetof(objobject, matrix), RO},
  {"type",   T_OBJECT, offsetof(objobject, type), RO},
  {NULL}
};

static PyObject*
obj_getattr(objobject* self, char* name)
{
  PyObject* rv;

  /* XXXX Add your own getattr code here */
  rv = PyMember_Get((char*) self, obj_memberlist, name);
  if (rv)
    {
      return rv;
    }
  PyErr_Clear();

  return Py_FindMethod(obj_methods, (PyObject*)self, name);
}


static int
obj_setattr(objobject* self, char* name, PyObject* v)
{
  /* XXXX Add your own setattr code here */
  if ( v == NULL )
    {
      PyErr_SetString(PyExc_AttributeError, "Cannot delete attribute");
      return -1;
    }

  return PyMember_Set((char*)/*XXXX*/0, obj_memberlist, name, v);
}

static char Objtype__doc__[] =
""
;

static PyTypeObject Objtype = {
  PyObject_HEAD_INIT(&PyType_Type)
  0,				/*ob_size*/
  "Object",			/*tp_name*/
  sizeof(objobject),	/*tp_basicsize*/
  0,				/*tp_itemsize*/
  /* methods */
  (destructor) obj_dealloc,	/*tp_dealloc*/
  (printfunc) obj_print,	/*tp_print*/
  (getattrfunc) obj_getattr,	/*tp_getattr*/
  (setattrfunc) obj_setattr,	/*tp_setattr*/
  (cmpfunc) 0,	/*tp_compare*/
  (reprfunc) obj_repr,		/*tp_repr*/
  0,		/*tp_as_number*/
  0,		/*tp_as_sequence*/
  0,		/*tp_as_mapping*/
  (hashfunc) 0,		/*tp_hash*/
  (ternaryfunc) 0,	/*tp_call*/
  (reprfunc) obj_str,		/*tp_str*/

  /* Space for future expansion */
  0L,0L,0L,0L,
  Objtype__doc__ /* Documentation string */
};

/*********/
/* scene */
/*********/

static char sce_addObject__doc__[] =
"addObject(self, object)"
;

static PyObject*
sce_addObject(sceobject* self, PyObject* args)
{
  int index;
  PyObject* object = NULL;

  if (!PyArg_ParseTuple(args, "O", &object))
    {
      return NULL;
    }
  PyList_Append(self->objects, object);
  index = PyList_Size(self->objects) - 1;

  return PyInt_FromLong(index);
}

static struct PyMethodDef sce_methods[] = {
  {"addObject",   (PyCFunction)sce_addObject,
   METH_VARARGS, sce_addObject__doc__},

  { NULL, NULL }
};

static sceobject*
newsceobject(char* name)
{
  sceobject* self;

  self = PyObject_NEW(sceobject, &Scetype);
  if (self == NULL)
    {
      return NULL;
    }
  strcpy(self->name, name);
  self->objects = PyList_New(0);

  return self;
}

static void
sce_dealloc(sceobject* self)
{
  sceobject* sce = (sceobject*) self;

  Py_DECREF(sce->objects);

  PyMem_DEL(self);
}

static int
sce_print(sceobject* self, FILE* fp, int flags)
{
  fprintf(fp, "Scene(name = \"%s\",\n", self->name);
  fprintf(fp, "      objects = %d)\n", PyList_Size(self->objects));

  return 0;
}

static PyObject*
sce_repr(sceobject* self)
{
  PyObject* s;

  s = PyString_FromString("Scene()\n");

  return s;
}

static PyObject*
sce_str(sceobject* self)
{
  PyObject* s;

  s = PyString_FromString("Scene()\n");

  return s;
}

#include "structmember.h"

static struct memberlist sce_memberlist[] = {
  /* XXXX Add lines like { "foo", T_INT, OFF(foo), RO }  */
  {"objects", T_OBJECT, offsetof(sceobject, objects), RO},
  {NULL}
};

static PyObject*
sce_getattr(sceobject* self, char* name)
{
  PyObject* rv;

  /* XXXX Add your own getattr code here */
  rv = PyMember_Get((char*) self, sce_memberlist, name);
  if (rv)
    {
      return rv;
    }
  PyErr_Clear();

  return Py_FindMethod(sce_methods, (PyObject*)self, name);
}


static int
sce_setattr(sceobject* self, char* name, PyObject* v)
{
  /* XXXX Add your own setattr code here */
  if ( v == NULL )
    {
      PyErr_SetString(PyExc_AttributeError, "Cannot delete attribute");
      return -1;
    }

  return PyMember_Set((char*)/*XXXX*/0, sce_memberlist, name, v);
}

static char Scetype__doc__[] =
""
;

static PyTypeObject Scetype = {
  PyObject_HEAD_INIT(&PyType_Type)
  0,				/*ob_size*/
  "Scene",			/*tp_name*/
  sizeof(sceobject),	/*tp_basicsize*/
  0,				/*tp_itemsize*/
  /* methods */
  (destructor) sce_dealloc,	/*tp_dealloc*/
  (printfunc) sce_print,	/*tp_print*/
  (getattrfunc) sce_getattr,	/*tp_getattr*/
  (setattrfunc) sce_setattr,	/*tp_setattr*/
  (cmpfunc) 0,	/*tp_compare*/
  (reprfunc) sce_repr,		/*tp_repr*/
  0,		/*tp_as_number*/
  0,		/*tp_as_sequence*/
  0,		/*tp_as_mapping*/
  (hashfunc) 0,		/*tp_hash*/
  (ternaryfunc) 0,	/*tp_call*/
  (reprfunc) sce_str,		/*tp_str*/

  /* Space for future expansion */
  0L,0L,0L,0L,
  Scetype__doc__ /* Documentation string */
};

static char blend_Mesh__doc__[] =
"Creates an (empty) instance of a Blender mesh.\n\
    E.g.: \"m = Blender.Mesh('Plane')\"\n\
    To create faces first add vertices with \n\
    \"i1 = m.addVertex(x, y, z, nx, ny, nz)\"\n\
    then create faces with \"index = m.addFace(i1, i2, i3, i4, isSmooth)\".\
"
;

static PyObject*
blend_Mesh(PyObject* self, PyObject* args)
{
  if (!PyArg_ParseTuple(args, ""))
    {
      return NULL;
    }

  Py_INCREF(Py_None);
  return Py_None;
}

static char blend_Object__doc__[] =
"Creates an instance of a Blender object"
;

static PyObject*
blend_Object(PyObject* self, PyObject* args)
{
  char* name = NULL;

  if (!PyArg_ParseTuple(args, "s", &name))
    {
      return NULL;
    }

  return ((PyObject*) newobjobject(name));
}

static char blend_Scene__doc__[] =
"Creates an instance of a Blender scene"
;

static PyObject*
blend_Scene(PyObject* self, PyObject* args)
{
  char* name = NULL;

  if (!PyArg_ParseTuple(args, "s", &name))
    {
      return NULL;
    }

  return ((PyObject*) newsceobject(name));
}

static char blend_addMesh__doc__[] =
"Blender.addMesh(type, scene)\n\
    where type is one of [\"Plane\"]"
;

static PyObject*
blend_addMesh(PyObject* self, PyObject* args)
{
  char* type = NULL;
  PyObject* scene   = NULL;
  PyObject* tuple   = NULL;
  PyObject* object  = NULL;
  PyObject* mesh    = NULL;
  PyObject* index   = NULL;
  PyObject* indices = NULL;

  if (!PyArg_ParseTuple(args, "sO", &type, &scene))
    {
      return NULL;
    }

  if (strcmp(type, "Plane") == 0)
    {
      object = (PyObject*) newobjobject(type);
      mesh   = (PyObject*) newmshobject(type);
      indices = PyList_New(5);
      /* vertices */
      index = msh_addVertex((mshobject*) mesh,
			    Py_BuildValue("ffffff", 
					  1.0, 1.0, 0.0, 0.0, 0.0, 1.0));
      PyList_SetItem(indices, 0, index);
      index = msh_addVertex((mshobject*) mesh,
			    Py_BuildValue("ffffff", 
					  1.0, -1.0, 0.0, 0.0, 0.0, 1.0));
      PyList_SetItem(indices, 1, index);
      index = msh_addVertex((mshobject*) mesh,
			    Py_BuildValue("ffffff", 
					  -1.0, -1.0, 0.0, 0.0, 0.0, 1.0));
      PyList_SetItem(indices, 2, index);
      index = msh_addVertex((mshobject*) mesh,
			    Py_BuildValue("ffffff", 
					  -1.0, 1.0, 0.0, 0.0, 0.0, 1.0));
      PyList_SetItem(indices, 3, index);
      PyList_SetItem(indices, 4, PyInt_FromLong(0)); /* smooth flag */
      /* faces */
      msh_addFace((mshobject*) mesh,
		  Py_BuildValue("OOOOO",
				PyList_GetItem(indices, 0),
				PyList_GetItem(indices, 3),
				PyList_GetItem(indices, 2),
				PyList_GetItem(indices, 1),
				PyList_GetItem(indices, 4)));
      /* connection */
      blend_connect(self, Py_BuildValue("OO", object, mesh));
      blend_connect(self, Py_BuildValue("OO", scene, object));
      /* return value */
      tuple = PyTuple_New(2);
      PyTuple_SetItem(tuple, 0, object);
      PyTuple_SetItem(tuple, 1, mesh);

      return tuple;
    }

  Py_INCREF(Py_None);
  return Py_None;
}

static char blend_connect__doc__[] =
"connect(obj1, obj2)"
;

static PyObject*
blend_connect(PyObject* self, PyObject* args)
{
  PyObject* obj1 = NULL;
  PyObject* obj2 = NULL;

  if (!PyArg_ParseTuple(args, "OO", &obj1, &obj2))
    {
      return NULL;
    }
  if (obj1->ob_type == &Objtype)
    {
      if (obj2->ob_type == &Mshtype)
	{
	  Py_INCREF(obj2);
	  ((objobject*) obj1)->data = obj2;
	  ((objobject*) obj1)->type = PyString_FromString("Mesh");
	}
    }
  else if (obj1->ob_type == &Scetype)
    {
      if (obj2->ob_type == &Objtype)
	{
	  sce_addObject((sceobject*) obj1, Py_BuildValue("(O)", obj2));
	}
    }

  Py_INCREF(Py_None);
  return Py_None;
}

static char blend_getCurrentScene__doc__[] =
"getCurrentScene()"
;

static PyObject*
blend_getCurrentScene(PyObject* self, PyObject* args)
{
  if (!PyArg_ParseTuple(args, ""))
    {
      return NULL;
    }

  Py_INCREF(_scene);
  return _scene;
}

/* List of methods defined in the module */

static struct PyMethodDef blend_methods[] = {
  {"Mesh",            (PyCFunction) blend_Mesh,
   METH_VARARGS, blend_Mesh__doc__},
  {"Object",          (PyCFunction) blend_Object,
   METH_VARARGS, blend_Object__doc__},
  {"Scene",           (PyCFunction) blend_Scene,
   METH_VARARGS, blend_Scene__doc__},
  {"addMesh",	      (PyCFunction) blend_addMesh,
   METH_VARARGS, blend_addMesh__doc__},
  {"connect",	      (PyCFunction) blend_connect,
   METH_VARARGS, blend_connect__doc__},
  {"getCurrentScene", (PyCFunction) blend_getCurrentScene,
   METH_VARARGS, blend_getCurrentScene__doc__},
  { NULL, (PyCFunction) NULL, 0, NULL }
};


/* Initialization function for the module (*must* be called initBlender) */

static char Blender_module_documentation[] =
"This is the Python API for Blender"
;

void
initBlender()
{
  PyObject* m;
  PyObject* d;

  /* Create the module and add the functions */
  m = Py_InitModule4("Blender", blend_methods,
		     Blender_module_documentation,
		     (PyObject*)NULL,PYTHON_API_VERSION);

  /* Add some symbolic constants to the module */
  d = PyModule_GetDict(m);
  ErrorObject = PyString_FromString("Blender.error");
  PyDict_SetItemString(d, "error", ErrorObject);

  /* XXXX Add constants here */
  _scene = (PyObject*) newsceobject("1");
  PyDict_SetItemString(d, "_scene", _scene);

  /* Check for errors */
  if (PyErr_Occurred())
    {
      Py_FatalError("can't initialize module Blender");
    }
}

int main(int argc, char* argv[])
{
  char filename[] = "test.py";
  FILE* fp = NULL;

  Py_SetProgramName("blender");
  Py_Initialize();
  initBlender();
  fp = fopen(filename, "r");
  PyRun_AnyFile(fp, filename);

  Py_Finalize();

  return EXIT_SUCCESS;
}