# supercloud.py
#
# Superboard II cloud service.
# Uses Redis as a data store for superboard instances and for work queues

import sys
sys.path.append("../Runner")
from msgservice import SuperService
import struct
import programmanager
import instancemanager
import jobqueue
from   superprogram import SuperProgram

class CloudService(SuperService):
    def __init__(self,*args,pm,im,jobqueue):
          super().__init__(*args)
          self.pm = pm
          self.im = im
          self.jobqueue = jobqueue
          
    def handle_request(self,requestno):
          '''
	  Handle cloud requests.   Requests are specified in the reserved
	  BASIC variable C$.   The following commands are implemented:
	  
	  SAVE NAME       -  Save the requesting program to NAME
	  CREATE NAME     -  Create a new instance NAME
	  LOAD NAME       -  Load a saved program
	  '''
          c = self.getvar("C$")
          print(c)
          args = c.split(None,1)
          print(args)
          if args[0][:1] == "S":     # SAVE
                ret = self.do_save(args[1])
          elif args[0][:1] == "L":   # LOAD
                ret = self.do_load(args[1])
          elif args[0][:1] == "C":   # CREATE INSTANCE
                ret = self.do_create(args[1])
          elif args[0][:1] == '.':   # Instance command
              ret = self.do_instance(args[0][1:],args[1])
          else:
                ret = -1
          return ret
          
    def do_save(self,name):
          '''
          Save an instance of the Superboard to Redis
          '''
          print("Saving", name)
          
          # Get information about the BASIC workspace
          basic_work = self.peek(0x79,55)
          print(basic_work)

          # Extract some information about BASIC data
          start_of_program, = struct.unpack("<H", basic_work[0:2])
          top_of_program, = struct.unpack("<H", basic_work[6:8])
          end_of_string, = struct.unpack("<H", basic_work[8:10])
          end_of_memory, = struct.unpack("<H", basic_work[10:12])
          
          # Go grab the basic program image
          program = self.peek(start_of_program, (top_of_program-start_of_program))
          strings = self.peek(end_of_string, (end_of_memory - end_of_string))
          
          # Make a program instance
          prog = SuperProgram(basic_work,program,strings)
          self.pm.save(name,prog)
          print("Saved", name)

    def do_load(self,name):
          '''
          Load an instance of the Superboard to Redis
          '''
          print("Loading", name)
          prog = self.pm.load(name)
          basic_work = prog.basicwork
          program = prog.program
          strings = prog.strings
          
          if not basic_work:
                return -1
          
          # Extract some information about BASIC data
          start_of_program, = struct.unpack("<H", basic_work[0:2])
          top_of_program, = struct.unpack("<H", basic_work[6:8])
          end_of_string, = struct.unpack("<H", basic_work[8:10])
          end_of_memory, = struct.unpack("<H", basic_work[10:12])

          print(start_of_program)
          print(top_of_program)
          print(end_of_string)
          print(end_of_memory)

          # Store data back on the Superboard
          self.poke(0x79, basic_work)
          self.poke(start_of_program, program)
          self.poke(end_of_string, strings)
          print("Loaded")

    def do_create(self,name):
        self.jobqueue.put(name.encode('latin-1')+b' CREATE')
        return 0
    def do_instance(self,name,args):
        # name is the instance name
        # args is the command arguments
        print(name,args)
        try:
            cmd, cmdargs = args.split(' ',1)
        except ValueError:
            cmd = args
            cmdargs = ""

        if cmd.startswith('L'):
            # Load a program
            self.jobqueue.put((name + ' ' + args).encode('latin-1'))
        elif cmd.startswith('I'):
            # Give input to a program
            self.jobqueue.put((name + ' ' + args+'\r').encode('latin-1'))
        elif cmd.startswith('G'):
            # Get a variable out of a program
            varname = cmdargs
            print("Looking for variable", varname)
            instance = self.im.load(name,busy=True,block=False)
            if instance:
                try:
                    value = instance.getvar(varname)
                    print("Got value", value)
                    self.setvar(varname,value)
                finally:
                    self.im.release(name)
            else:
                return -1
        elif cmd.startswith("D"):
            # Show the instance display
            instance = self.im.load(name,busy=True,block=False)
            if instance:
                try:
                    screendata = instance.peek(0xd000,0x400)
                    self.poke(0xd000,screendata)
                finally:
                    self.im.release(name)
            else:
                return -1
        elif cmd.startswith("PE"):
            args = cmdargs.split()
            saddr = int(args[0])
            sz = int(args[1])
            taddr = int(args[2])
            # Transfer data from the instance to the Superboard
            instance = self.im.load(name,busy=True,block=False)
            if instance:
                try:
                    data = instance.peek(saddr,sz)
                    self.poke(taddr,data)
                    return len(data)
                finally:
                    self.im.release(name)
            else:
                return -1

        elif cmd.startswith("PO"):
            args = cmdargs.split()
            saddr = int(args[0])
            sz = int(args[1])
            taddr = int(args[2])
            # Transfer data from the instance to the Superboard
            instance = self.im.load(name,busy=True,block=False)
            if instance:
                try:
                    data = self.peek(saddr,sz)
                    instance.poke(taddr,data)
                    self.im.save(name,instance)
                    return len(data)
                finally:
                    self.im.release(name)
            else:
                return -1

        else:
            print("Bad command", cmd)
            return -1

if __name__ == '__main__':
    serv = CloudService(0,pm=programmanager.RedisProgramManager(),
                          im=instancemanager.RedisInstanceManager(screendir="../Runner/screens"),
                          jobqueue = jobqueue.RedisQueue())
    serv.start()