#!/bin/python3
'''
Created on Mar 31, 2014

@author: tpweis
'''
import os
import sys
import subprocess
import syslog
import pymongo
from datetime import datetime, date, time
from calendar import timegm
import iso8601
import time
import json
import re

def get_addrlist(start_addr=0, count=0, roll_over='yes'):
    "function get_addrlist()"

    argv = sys.argv[1:]

    empty_list = []
    # check for values
    if start_addr == 0:
        slscatlog('E','Missing IP address.  Try again')
        return empty_list

    addr_count = 0
    try:
        addr_count = int(count)
    except:
        slscatlog('E',"Address count is bad: " + count)

    if addr_count == 0:
        slscatlog('E','Missing address count.  Try again')
        return empty_list

    if roll_over not in ["no", "yes"]:
            roll_over = "yes"

    slscatlog('D',"args: " + start_addr + ", " + str(addr_count) + ", " + roll_over)

    # First break apart the input address to its respective octets

    octet_list = re.split(r'(\.)',start_addr)
    # Do a little error checking.
    # We must have at least 7 elements in the list, or it cannot be an IP4 address
    if len(octet_list) < 7 :
        slscatlog('E',"Octet list incomplete.  Len = " + str(len(octet_list)))
        return empty_list

    # the IP address values are in the list, separated by '.' (dot)
    first_octet = octet_list[0]
    second_octet = octet_list[2]
    third_octet = octet_list[4]
    fourth_octet = octet_list[6]

    # Ensure the starting address is valid

    bad_address = False
    if int(first_octet) not in range(0,255):
        slscatlog('E',"first octet is bad: " + first_octet)
        bad_address = True

    if int(second_octet) not in range(0,255):
        slscatlog('E',"second octet is bad: " + second_octet)
        bad_address = True

    if int(third_octet) not in range(0,255):
        slscatlog('E',"third octet is bad: " + third_octet)
        bad_address = True

    if int(fourth_octet) not in range(0,255):
        slscatlog('E',"fourth_octet is bad: " + fourth_octet)
        bad_address = True

    if bad_address:
        return empty_list

    slscatlog('D',"Input octet list: " + ', '.join(octet_list))

    # Start constructing the new address list
    ipcount = 0
    a = int(first_octet)
    b = int(second_octet)
    c = int(third_octet)
    d = int(fourth_octet)
    addr_list = []
    # Do this loop 'addr_count' times, unless we run out of numbers.
    while ipcount < addr_count:
        # Increment the counter
        ipcount += 1
        d +=1
        # check for any octet overflow
        if d > 254:
            if roll_over == "yes":
                d = 0
                c += 1
                slscatlog('D',"rollover: d = 0, c = " + str(c))
            else:
            # Note that we only need to check this in one place
            # because we cannot increment the following octets without
            # rolling over the last octet.  If we can't roll over, but haven't
            # satisfied the addr_count, this is an error and produces an empty list
                slscatlog('I',"Roll over set to no, ran out of available addresses at: " + '.'.join([str(a),str(b),str(c),str(d)]))
                return empty_list

        if c > 254:
            c = 0
            b += 1

        if b > 254:
            b = 0
            a += 1

        if a > 254:
            # We ran out of numbers.  Error out
            slscatlog('E'," Ran out of available addresses: " + '.'.join([str(a),str(b),str(c),str(d)]))
            return empty_list
        # Compose the new address
        new_addr = '.'.join([str(a),str(b),str(c),str(d)])
        slscatlog('I',"New address: " + new_addr)
        addr_list.append(new_addr)

    return addr_list

def slscatfunction( cmd, ipaddr, user, urn, mongo ):
    "function slscatfunction"

    q1=subprocess.Popen(["echo", cmd, user, urn, mongo], stdout=subprocess.PIPE)
    q2=subprocess.Popen(["nc", "-n", ipaddr, str(52525)], stdin=q1.stdout, stdout=subprocess.PIPE)
    qdata=q2.communicate()[0]
    qdata=qdata.decode()
    qdata=qdata.rstrip()

    slscatlog('D',"run: " + cmd + ", result is " + qdata)
    return qdata

def slscatlog(level, message):
    "function slscatlog()"
    try:
        from scatconf import scat_loglevel
    except ImportError:
        scat_loglevel = 7
        msgpri4 = 6 | syslog.LOG_LOCAL4
#        msgpri5 = 6 | syslog.LOG_LOCAL5
        syslog.syslog(msgpri4,"INFO: No scat logging config in place")
#        syslog.syslog(msgpri5,"INFO: No scat logging config in place")

    syslog.openlog(ident='scat', facility=syslog.LOG_LOCAL4)
#    syslog.openlog(ident='scattest', facility=syslog.LOG_LOCAL5)
#    logmask = syslog.LOG_UPTO(scat_loglevel)
#    syslog.setlogmask(logmask)

    if level=='D':
        outmsg = "DEBUG: " + message
        outlevel = 7
    elif level=='I':
        outmsg = "INFO:  " + message
        outlevel = 6
    elif level=='W':
        outmsg = "WARN:  " + message
        outlevel = 4
    elif level=='E':
        outmsg = "ERROR: " + message
        outlevel = 3
    else:
        outmsg = "BAD LOG ENTRY: " + message
        outlevel = 2
    msgpri4 = outlevel | syslog.LOG_LOCAL4
#    msgpri5 = outlevel | syslog.LOG_LOCAL5
    syslog.syslog(msgpri4,outmsg)
#    syslog.syslog(msgpri5,outmsg)
    return outmsg

def slscatargs( arglist):
    "function slscatargs()"
    if(len(arglist)< 1):
        slscatlog('E','Missing IP address.  Try again')
        sys.exit(3)
    else:
        IPADDR = arglist[0]

    if(len(arglist) < 2):
        USER = 'NO_USER'
    else:
        USER = arglist[1]

    if(len(arglist) < 3):
        URN = 'NO_URN'
    else:
        URN = arglist[2]

    if(len(arglist) < 4):
        MONGO = 'NO_MONGO'
    else:
        MONGO = arglist[3]

    slscatlog('D',"slscatargs: " + IPADDR + ", " + USER + ", " + URN + ", " + MONGO)
    good_args = IPADDR, USER, URN, MONGO
    return good_args

def slbinget():
    "function slbinget"
    return "/sl/bin/"  

def slscatget():
    "function slscatget"
    return "/sl/scat/"  

def slhomeget():
    "function slhomeget()"
    return "/sl/"

def sllogget():
    "function sllogget()"
    return "/sl/logs/"

def slrunget():
    "function slrunget()"
    return "/sl/run/"

def sltomcatbinget():
    "function sltomcatbinget()"
    return "/usr/local/tomcat/bin/"

def slsetvars():
    "function slsetvars"

    os.environ["SEQUENCE_LOGIC_ENV"] = "system"
    os.environ["SEQUENCELOGICHOME"] = "/sl"
    os.environ["PLATFORM"] = "lin64"
    os.environ["SLSYNC"] = slhomeget() +"/SLSync"
    os.environ["EYE_DIR"] = slbinget()
    os.environ["CRYPTO_DIR"] = os.environ.get("EYE_DIR", "Not Set")
    os.environ["K2C_DIR"] =  os.environ.get("EYE_DIR", "Not Set")
    os.environ["CPP_DIR"] = os.environ.get("EYE_DIR", "Not Set")
    os.environ["JAR"] = os.environ.get("EYE_DIR", "Not Set")  + "/robot-1.0.0.one-jar.jar"
    os.environ["LD_LIBRARY_PATH"] = \
        os.environ.get("K2C_DIR", "Not Set") + ":" + \
        os.environ.get("CRYPTO_DIR", "Not Set") + ":" + \
        os.environ.get("EYE_DIR", "Not Set") + ":" + \
        os.environ.get("CPP_DIR", "Not Set") + ":" + \
        "/usr/local/lib"
    os.environ["java_library_path"] = \
        os.environ.get("EYE_DIR", "Not Set") + ":" + \
        os.environ.get("CRYPTO_DIR", "Not Set") + ":" + \
        os.environ.get("K2C_DIR", "Not Set") + ":" + \
        os.environ.get("CPP_DIR", "Not Set")
"""
    subprocess.call(["echo", "PLATFORM=",  os.environ.get("PLATFORM", "Not Set")])
    subprocess.call(["echo", "SLSYNC=", os.environ.get("SLSYNC", "Not Set")])
    subprocess.call(["echo", "EYE_DIR=", os.environ.get("EYE_DIR", "Not Set")])
    subprocess.call(["echo", "CRYPTO_DIR=", os.environ.get("CRYPTO_DIR", "Not Set")])
    subprocess.call(["echo", "K2C_DIR=", os.environ.get("K2C_DIR", "Not Set")])
    subprocess.call(["echo", "CPP_DIR=", os.environ.get("CPP_DIR", "Not Set")])
    subprocess.call(["echo", "JAR=", os.environ.get("JAR", "Not Set")])
    subprocess.call(["echo", "LD_LIBRARY_PATH=", os.environ.get("LD_LIBRARY_PATH", "Not Set")])
    subprocess.call(["echo", "java_library_path=", os.environ.get("java_library_path", "Not Set")])
"""

def utctimenow():
  #############################################################
  ## return the current time in utc format (iso8601)
  timenow=datetime.utcnow().isoformat()+"Z"
  return(timenow)


###############################################################
def getutcfromtimestamp(timestamp):
  #############################################################
  ## This routine converts from a timestamp to a utc string.
  tstring=datetime.utcfromtimestamp(timestamp).isoformat()+"Z"
  return(tstring)

###############################################################
def gettimestampfromutc(iso_string):
  #############################################################
  ## This routine takes a date string that is formated as UTC
  ## and returns a unix timestamp (seconds since 1970-Jan-01)
  m=0
  iso_string=iso_string.rstrip('Z')
  iso_string=iso_string.rstrip('T')
  print("\n\n---ISO_STRING:",iso_string)
  try:
     ### First, letst convert to datetime so we can collect u_sec
     uu=datetime.strptime(iso_string,'%Y-%m-%dT%H:%M:%S.%f')
     m=uu.microsecond
     ### Convert to a shorter datetime struct
     uu=uu.strftime('%Y-%m-%dT%H:%M:%S')
     du=datetime.strptime(uu,'%Y-%m-%dT%H:%M:%S')
     ### Convert to a time struct from shortened format
     ru=time.strptime(uu,'%Y-%m-%dT%H:%M:%S')
     uu=ru
  except:
     o=1

  try:
     ## string without milliseconds
     uu=time.strptime(iso_string,'%Y-%m-%dT%H:%M:%S')
  except:
     o=1

  try:
     ## date without time
     uu=time.strptime(iso_string,'%Y-%m-%d')
  except:
     o=1


  ts = timegm( uu )

  ## if u_secs were saved off, add back on to the end of the string
  if (m):
    ts=ts + m/1000000
  print("RETURN:", ts)
  return(ts)

############ Write a Fact ##############
# Assumes a global of "factsdir" this should be fixed
def writeFact( string, filename, factsdir = "/etc/sleds/facts" ):

  filename=factsdir+"/"+filename
  f = open(filename,"w")
  print("Writing to filename: "+filename)
  f.write(string)
  f.write("\n")
  f.close()

############ go issue a sub command / shell ###########
def pipe (cmd):
  proc = subprocess.Popen( cmd ,
      stdin=subprocess.PIPE,
      stdout=subprocess.PIPE,
      )

  data=proc.communicate()[0]
  data=data.decode()
  return(data)

def myipaddr():
  ### Second, lets collect our current IP address
  cmd="facter ipaddress"
  cmd=cmd.split()

  data=pipe(cmd)
  data=data.rstrip()
  ip=data
  return(ip)

def myregkey():
  ### lets collect our current Registration Key Value
  cmd="facter sleds-regkey"
  cmd=cmd.split()

  data=pipe(cmd)
  data=data.rstrip()
  rkey=data
  return(rkey)


###############################################################



def main():
    "function main"
    slsetvars()

    # execute only if run as a script
if __name__ == "__main__":
     # execute only if run as a script
    main()