import ctypes

import qemu

import sys

#import SyborgModule

class syborg_graphicsdevice(qemu.devclass):

    # Graphics device registers derived from VirtualVideoInterfaceConstants.h

    VVI_R_ID                                = 0x0000

    VVI_R_IRQ_ENABLE                        = 0x0004

    VVI_R_IRQ_STATUS                        = 0x0008

    VVI_R_COMMAND                           = 0x000c

    VVI_R_PARAMETER_LOAD                    = 0x0010

    VVI_R_ERROR                             = 0x0014

    VVI_R_INPUT_BUFFER_TAIL                 = 0x0018

    VVI_R_INPUT_BUFFER_HEAD                 = 0x001c

    VVI_R_INPUT_BUFFER_READ_COUNT           = 0x0020

    VVI_R_INPUT_BUFFER_WRITE_COUNT          = 0x0024

    VVI_R_INPUT_BUFFER_MAX_TAIL             = 0x0028

    VVI_R_REQUEST_ID                        = 0x002c

    VVI_R_SHARED_CMD_MEMORY_BASE            = 0x0030

    VVI_R_SHARED_FRAMEBUFFER_MEMORY_BASE    = 0x0034

    VVI_R_LASTREG                           = 0x0038  # not a register, address of last register

    VVI_EXECUTE                             = 0

    shared_cmd_memory_base                  = 0

    shared_framebuffer_memory_base          = 0

    m_request_id_reg = 0

    # Memory base id's from SyborgModule.h

    # SYBORG_CMDMEMBASE = 0

    # SYBORG_FRAMEBUFFERMEMBASE = 1

    class DllLoadExeption( Exception ):

        def __init__(self,value):

            self.value = value

        def __str__(self):

            return repr(self.value)

    class SyborgGraphicsWrapper():

        def __init__(self):

            try:

                self.library = ctypes.CDLL("syborg-graphicswrapper.dll")

            except:

                raise syborg_graphicsdevice.DllLoadExeption(1)

            self.obj = self.library.create_SyborgGraphicsWrapper()

        def initialize_graphics_utils(self):

            self.library.initialize_SyborgGraphicsWrapper( self.obj )

    def create(self):

        try:

            self.graphicsutils = self.SyborgGraphicsWrapper()

        except syborg_graphicsdevice.DllLoadExeption:

            #print "syborg_graphicsdevice: Graphics dll load failed"

            sys.exit("syborg_graphicsdevice: Graphics dll load failed")

        self.graphicsutils.initialize_graphics_utils()

        self.initialize_graphics_callback()

        # deliver the graphics ram region

        # self.gmembase = self.graphicsutils.library.get_membase()

        self.irqenable = 0

        self.irqstatus = 0

        self.command = 0

        self.parameterload = 0

    def updateIrq(self,new_value):

        self.set_irq_level(0, new_value)

    def graphics_request_callback(self, request_id):

        #print "graphics_request_callback: " , request_id

        self.m_request_id_reg = request_id

        self.updateIrq(1)

        return 0

    def initialize_graphics_callback(self):

        self.CALLBACKFUNC = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int)

        self.graphics_callback = self.CALLBACKFUNC(self.graphics_request_callback)

        self.graphicsutils.library.set_GraphicsCallBack( self.graphicsutils.obj, self.graphics_callback )

    def read_reg(self, offset):

        offset >>= 2

        if offset == self.VVI_R_ID:

            return 0xDEADBEEF

        elif offset == self.VVI_R_IRQ_ENABLE:

            return self.irqenable

        elif offset == self.VVI_R_IRQ_STATUS:

            return self.irqstatus

        elif offset == self.VVI_R_COMMAND:

            return self.command

        elif offset == self.VVI_R_PARAMETER_LOAD:

            return self.parameterload

        elif offset == self.VVI_R_ERROR:

            self.lasterror = 0

            return self.lasterror

        elif offset == self.VVI_R_INPUT_BUFFER_TAIL:

            return self.graphicsutils.library.get_InputBufferTail( self.graphicsutils.obj )

        elif offset == self.VVI_R_INPUT_BUFFER_HEAD:

            return self.graphicsutils.library.get_InputBufferHead( self.graphicsutils.obj )

        elif offset == self.VVI_R_INPUT_BUFFER_READ_COUNT:

            return self.graphicsutils.library.get_InputBufferReadCount( self.graphicsutils.obj )

        elif offset == self.VVI_R_INPUT_BUFFER_WRITE_COUNT:

            return self.graphicsutils.library.get_InputBufferWriteCount( self.graphicsutils.obj )

        elif offset == self.VVI_R_INPUT_BUFFER_MAX_TAIL:

            return self.graphicsutils.library.get_InputMaxTailIndex( self.graphicsutils.obj )

        elif offset == self.VVI_R_REQUEST_ID:

            return self.m_request_id_reg

        elif offset == self.VVI_R_SHARED_CMD_MEMORY_BASE:

            return self.shared_cmd_memory_base

        elif offset == self.VVI_R_SHARED_FRAMEBUFFER_MEMORY_BASE:

            return self.shared_framebuffer_memory_base

        else:

            reg_read_error = "syborg_graphicsdevice: Illegal register read at: ", offset 

            sys.exit( reg_read_error )

    def write_reg(self, offset, value):

        offset >>= 2

        if offset == self.VVI_R_IRQ_STATUS:

            self.updateIrq(0);

            self.graphicsutils.library.signal_outputbuffer_semafore( self.graphicsutils.obj )

            self.graphicsutils.library.execute_command( self.graphicsutils.obj );

        elif offset == self.VVI_R_COMMAND:

            if value == self.VVI_EXECUTE:

                self.graphicsutils.library.execute_command( self.graphicsutils.obj );

            else:

                sys.exit("syborg_graphicsdevice: Unknown command issued!")

        elif offset == self.VVI_R_INPUT_BUFFER_TAIL:

            self.graphicsutils.library.set_InputBufferTail(  self.graphicsutils.obj, value );

        elif offset == self.VVI_R_INPUT_BUFFER_HEAD:

            self.graphicsutils.library.set_InputBufferHead( self.graphicsutils.obj, value );

        elif offset == self.VVI_R_INPUT_BUFFER_READ_COUNT:

            self.graphicsutils.library.set_InputBufferReadCount( self.graphicsutils.obj, value );

        elif offset == self.VVI_R_INPUT_BUFFER_WRITE_COUNT:

            self.graphicsutils.library.set_InputBufferWriteCount( self.graphicsutils.obj, value );

        elif offset == self.VVI_R_INPUT_BUFFER_MAX_TAIL:

            self.graphicsutils.library.set_InputMaxTailIndex( self.graphicsutils.obj, value );

        elif offset == self.VVI_R_SHARED_CMD_MEMORY_BASE:

            gmemsize = self.graphicsutils.library.get_cmd_memsize()

            self.cmd_memregion = qemu.memregion( value, gmemsize )

            self.memregion_cmd_base = self.cmd_memregion.region_host_addr()

            #SyborgModule.post_address( self.memregion_cmd_base, self.SYBORG_CMDMEMBASE )

        elif offset == self.VVI_R_SHARED_FRAMEBUFFER_MEMORY_BASE:

            gmemsize = self.graphicsutils.library.get_framebuffer_memsize()

            self.framebuffer_memregion = qemu.memregion( value, gmemsize )

            self.memregion_framebuffer_base = self.framebuffer_memregion.region_host_addr()

            #SyborgModule.post_address( self.memregion_framebuffer_base, self.SYBORG_FRAMEBUFFERMEMBASE )

            # Ready to finalise graphics initialization

            if( self.graphicsutils.library.reset_SyborgGraphicsWrapper( self.graphicsutils.obj, self.memregion_framebuffer_base, self.memregion_cmd_base ) != 0 ):

                sys.exit("syborg_graphicsdevice: Syborg graphicsutils library not initialized correctly!")

        else:

            reg_write_error = "syborg_graphicsdevice: Illegal register write to: ", offset 

            sys.exit( reg_write_error )

    # Device class properties

    regions = [qemu.ioregion(0x1000, readl=read_reg, writel=write_reg)]

    irqs = 1

    name = "syborg,graphicsdevice"

    properties = {}

qemu.register_device(syborg_graphicsdevice)