# -*- coding: utf-8 -*-
# queue for recieve is pushing and poping wrong way should be a fifi stack

# may be some dead code, need to coordinate with the simulator

#import antigravity
import serial
import sys


class RS232Driver:


    def __init__(self,  aController  ): ### (1a)

        self.name          = "class named RS232Diver"


        self.myController   = aController

        self.myParameters   = aController.myParameters
        self.myLogger       = aController.myLogger

        self.driver         = serial.Serial()

        self.isopen         = False

        self.recBuff        = ""    # buffer recieved data

        self.recData        = bytearray( "" )    # data that has been recieved.

        '''
        this was for simulator
        self.gotDataBuff    = ""   # simulated data for next recieve.
        self.gotDataIx      = 0
        self.gotDataData    = []
        self.gotDataData.append( "rec" )
        self.gotDataData.append( "eived" )
        self.gotDataData.append( "\n" )
        self.gotDataData.append( "666\n" )
        self.gotDataData.append( "3.1415" )
        self.gotDataData.append( "9\n" )
        self.gotDataData.append( "russ\n" )
        self.gotDataData.append( "xxy" )
        self.gotDataData.append( "y\n" )
        self.gotDataData.append( "rec" )
        self.gotDataData.append( "penultimate\n" )
        self.gotDataData.append( "end\n" )
        '''


    def getName( self, ):

        return self.name


    def getOpen( self, ):

               return self.isopen


    def close(self, ):

        self.myController.log( "closing com", "print"  )

        self.driver.close()
        self.isopen  = False

        return


    def open(self, ):
        """
        tries to open port
        returns true if port opens
        gets parms itself see setParms
        """

        self.myController.log( "opening com driver", "print"  )
        self.setParms()

        retval   = True

        try:
            self.driver.open()

        except Exception as excpt:
            #print type(inst)     # the exception instance
            #print inst.args      # arguments stored in .args
            #print inst           # __str__ allows args to printed directly
            #x, y = inst.args

            retval   = False

        self.isopen  = retval

        return  retval


    def setParms(self, ):
        """
        set the parameters of the port from Parameters instance
        todo   make sure port closed first?  set status to self.isopen = False

        """

        self.driver.port        =       self.myParameters.port

        self.driver.baudrate    =       self.myParameters.baudrate

        self.driver.parity      =       self.myParameters.parity

        self.driver.stopbits    =       self.myParameters.stopbits

        self.driver.bytesize    =       self.myParameters.bytesize

        #ser = serial.Serial(0)

        #self.recTimeout          = self.myParameters.recTimeout

        return self.name


    def send( self, adata):
        """
        sends the data ( if port is open )
        return  nothing
        """

        # note early returns on error
        if self.isopen == False:
            return

        self.myController.log( "sending >" + adata, "print" )

        data   = adata + self.myParameters.serialAppend    # if configured

        self.driver.write( bytearray(data, 'utf8' ) )    # "ascii"  'utf8'

        return

    def getRecString( self, ):
        """
        may not get the string untill completed
        strips some special characters
        note: early return
        """

        if self.isopen == False:
            return ""

        #define at instance level
        int_newline  =  ord( "\n" )
        int_cr       =  ord( "\r" )


        done = False
        no_waiting   = self.driver.inWaiting()
        if no_waiting > 0:
            rec_bytes = bytearray ( self.driver.read(size = no_waiting) ) # convert bytes to byte array
        else:
           retval = ""
           return retval
        # check that we have not got end of string marker what is it cr or lf /n
        # use in syntax when have figured out

        if  ( rec_bytes[-1 ] == int_newline ) or ( rec_bytes[-1] == int_cr ):
            del rec_bytes[-1]
            done = True
            print "the end"
        if len( rec_bytes ) > 0 and ( ( rec_bytes[-1 ] == int_newline ) or ( rec_bytes[-1] == int_cr ) ):
            del rec_bytes[-1]

        self.recData =  self.recData + rec_bytes

        if done:
            retval = str( self.recData )
            self.recData = bytearray( "" )
            # save a prior copy??
        else:
            retval = ""

        return retval


    def getdataxxx( self ):
        """
        return data where we have complete lines, test first with gotdata?
        todo droppint????
        """
        # or do gotData and use its return??
        # lenix   = self.recData.len()
        self.gotdata()
        lenix    = len( self.recData )
        if lenix  == 0:
            return ""

        retData  = self.recData.pop(0)

        return retData


    def gotdataxxxxxxxxxxxx( self ):
        """
        return length of recData list
        or should we put in a list a new item each time this would be a que

        """
        # =========================
        #data = readline( size=None, eol='\n' )


        data = self.gotDataBuff
        self.gotDataBuff  =  ""
        # =========================

        if data == "":
            return len( self.recBuff )
        self.recBuff  = self.recBuff + data
        print "gotdata()" + self.recBuff
        print self.recBuff
        print "suffix>"  + self.recBuff[ len( self.recBuff ) -1 ]
        sys.stdout.flush()
        if self.recBuff[ len( self.recBuff ) -1 ]  == "\n":   # may be a more pythonic slice way of doi9ng this [-1]?
            # make copy of it , clening it up
            print "got crlf"
            self.recData.append( ''.join( self.recBuff ) ) # may not apply to immutables
            self.recBuff = ""
            sys.stdout.flush()


        return len( self.recBuff )