#!/usr/bin/python2.7
# -*- coding: utf-8 -*-
# pylint: disable=too-many-lines,global-statement,too-many-branches,too-many-statements,inconsistent-return-statements
# pylint: disable=too-many-nested-blocks,too-many-locals,protected-access,too-many-arguments,too-many-function-args
# pylint: disable=no-member
"""
Created by Adam Melton (.dok) referenceing https://bitmessage.org/wiki/API_Reference for API documentation
Distributed under the MIT/X11 software license. See http://www.opensource.org/licenses/mit-license.php.

This is an example of a daemon client for PyBitmessage 0.6.2, by .dok (Version 0.3.1) , modified

TODO: fix the following (currently ignored) violations:

"""

import xmlrpclib
import datetime
import imghdr
import ntpath
import json
import socket
import time
import sys
import os

from bmconfigparser import BMConfigParser


api = ''
keysName = 'keys.dat'
keysPath = 'keys.dat'
# 0 = First Start, 1 = prompt, 2 = no prompt if the program is starting up
usrPrompt = 0
knownAddresses = dict()


def userInput(message):
    """Checks input for exit or quit. Also formats for input, etc"""

    global usrPrompt

    print('\n' + message)
    uInput = raw_input('> ')

    if uInput.lower() == 'exit':  # Returns the user to the main menu
        usrPrompt = 1
        main()

    elif uInput.lower() == 'quit':  # Quits the program
        print('\n     Bye\n')
        sys.exit(0)

    else:
        return uInput


def restartBmNotify():
    """Prompt the user to restart Bitmessage"""
    print('\n     *******************************************************************')
    print('     WARNING: If Bitmessage is running locally, you must restart it now.')
    print('     *******************************************************************\n')


# Begin keys.dat interactions


def lookupAppdataFolder():
    """gets the appropriate folders for the .dat files depending on the OS. Taken from bitmessagemain.py"""

    APPNAME = "PyBitmessage"
    if sys.platform == 'darwin':
        if "HOME" in os.environ:
            dataFolder = os.path.join(os.environ["HOME"], "Library/Application support/", APPNAME) + '/'
        else:
            print(
                '     Could not find home folder, please report '
                'this message and your OS X version to the Daemon Github.')
            sys.exit(1)

    elif 'win32' in sys.platform or 'win64' in sys.platform:
        dataFolder = os.path.join(os.environ['APPDATA'], APPNAME) + '\\'
    else:
        dataFolder = os.path.expanduser(os.path.join("~", ".config/" + APPNAME + "/"))
    return dataFolder


def configInit():
    """Initialised the configuration"""

    BMConfigParser().add_section('bitmessagesettings')
    # Sets the bitmessage port to stop the warning about the api not properly
    # being setup. This is in the event that the keys.dat is in a different
    # directory or is created locally to connect to a machine remotely.
    BMConfigParser().set('bitmessagesettings', 'port', '8444')
    BMConfigParser().set('bitmessagesettings', 'apienabled', 'true')  # Sets apienabled to true in keys.dat

    with open(keysName, 'wb') as configfile:
        BMConfigParser().write(configfile)

    print('\n     ' + str(keysName) + ' Initalized in the same directory as daemon.py')
    print('     You will now need to configure the ' + str(keysName) + ' file.\n')


def apiInit(apiEnabled):
    """Initialise the API"""

    global usrPrompt
    BMConfigParser().read(keysPath)

    if apiEnabled is False:  # API information there but the api is disabled.
        uInput = userInput("The API is not enabled. Would you like to do that now, (Y)es or (N)o?").lower()

        if uInput == "y":
            BMConfigParser().set('bitmessagesettings', 'apienabled', 'true')  # Sets apienabled to true in keys.dat
            with open(keysPath, 'wb') as configfile:
                BMConfigParser().write(configfile)

            print('Done')
            restartBmNotify()
            return True

        elif uInput == "n":
            print('     \n************************************************************')
            print('            Daemon will not work when the API is disabled.       ')
            print('     Please refer to the Bitmessage Wiki on how to setup the API.')
            print('     ************************************************************\n')
            usrPrompt = 1
            main()

        else:
            print('\n     Invalid Entry\n')
            usrPrompt = 1
            main()

    elif apiEnabled:  # API correctly setup
        # Everything is as it should be
        return True

    else:  # API information was not present.
        print('\n     ' + str(keysPath) + ' not properly configured!\n')
        uInput = userInput("Would you like to do this now, (Y)es or (N)o?").lower()

        if uInput == "y":  # User said yes, initalize the api by writing these values to the keys.dat file
            print(' ')

            apiUsr = userInput("API Username")
            apiPwd = userInput("API Password")
            apiPort = userInput("API Port")
            apiEnabled = userInput("API Enabled? (True) or (False)").lower()
            daemon = userInput("Daemon mode Enabled? (True) or (False)").lower()

            if (daemon != 'true' and daemon != 'false'):
                print('\n     Invalid Entry for Daemon.\n')
                uInput = 1
                main()

            print('     -----------------------------------\n')

            # sets the bitmessage port to stop the warning about the api not properly
            # being setup. This is in the event that the keys.dat is in a different
            # directory or is created locally to connect to a machine remotely.
            BMConfigParser().set('bitmessagesettings', 'port', '8444')
            BMConfigParser().set('bitmessagesettings', 'apienabled', 'true')
            BMConfigParser().set('bitmessagesettings', 'apiport', apiPort)
            BMConfigParser().set('bitmessagesettings', 'apiinterface', '127.0.0.1')
            BMConfigParser().set('bitmessagesettings', 'apiusername', apiUsr)
            BMConfigParser().set('bitmessagesettings', 'apipassword', apiPwd)
            BMConfigParser().set('bitmessagesettings', 'daemon', daemon)
            with open(keysPath, 'wb') as configfile:
                BMConfigParser().write(configfile)

            print('\n     Finished configuring the keys.dat file with API information.\n')
            restartBmNotify()
            return True

        elif uInput == "n":
            print('\n     ***********************************************************')
            print('     Please refer to the Bitmessage Wiki on how to setup the API.')
            print('     ***********************************************************\n')
            usrPrompt = 1
            main()
        else:
            print('     \nInvalid entry\n')
            usrPrompt = 1
            main()


def apiData():
    """TBC"""

    global keysName
    global keysPath
    global usrPrompt

    BMConfigParser().read(keysPath)  # First try to load the config file (the keys.dat file) from the program directory

    try:
        BMConfigParser().get('bitmessagesettings', 'port')
        appDataFolder = ''
    except:
        # Could not load the keys.dat file in the program directory. Perhaps it is in the appdata directory.
        appDataFolder = lookupAppdataFolder()
        keysPath = appDataFolder + keysPath
        BMConfigParser().read(keysPath)

        try:
            BMConfigParser().get('bitmessagesettings', 'port')
        except:
            # keys.dat was not there either, something is wrong.
            print('\n     ******************************************************************')
            print('     There was a problem trying to access the Bitmessage keys.dat file')
            print('                    or keys.dat is not set up correctly')
            print('       Make sure that daemon is in the same directory as Bitmessage. ')
            print('     ******************************************************************\n')

            uInput = userInput("Would you like to create a keys.dat in the local directory, (Y)es or (N)o?").lower()

            if (uInput == "y" or uInput == "yes"):
                configInit()
                keysPath = keysName
                usrPrompt = 0
                main()
            elif (uInput == "n" or uInput == "no"):
                print('\n     Trying Again.\n')
                usrPrompt = 0
                main()
            else:
                print('\n     Invalid Input.\n')

            usrPrompt = 1
            main()

    try:  # checks to make sure that everyting is configured correctly. Excluding apiEnabled, it is checked after
        BMConfigParser().get('bitmessagesettings', 'apiport')
        BMConfigParser().get('bitmessagesettings', 'apiinterface')
        BMConfigParser().get('bitmessagesettings', 'apiusername')
        BMConfigParser().get('bitmessagesettings', 'apipassword')

    except:
        apiInit("")  # Initalize the keys.dat file with API information

    # keys.dat file was found or appropriately configured, allow information retrieval
    # apiEnabled =
    # apiInit(BMConfigParser().safeGetBoolean('bitmessagesettings','apienabled'))
    # #if false it will prompt the user, if true it will return true

    BMConfigParser().read(keysPath)  # read again since changes have been made
    apiPort = int(BMConfigParser().get('bitmessagesettings', 'apiport'))
    apiInterface = BMConfigParser().get('bitmessagesettings', 'apiinterface')
    apiUsername = BMConfigParser().get('bitmessagesettings', 'apiusername')
    apiPassword = BMConfigParser().get('bitmessagesettings', 'apipassword')

    print('\n     API data successfully imported.\n')

    # Build the api credentials
    return "http://" + apiUsername + ":" + apiPassword + "@" + apiInterface + ":" + str(apiPort) + "/"


# End keys.dat interactions


def apiTest():
    """Tests the API connection to bitmessage. Returns true if it is connected."""

    try:
        result = api.add(2, 3)
    except:
        return False

    return result == 5


def bmSettings():
    """Allows the viewing and modification of keys.dat settings."""

    global keysPath
    global usrPrompt

    keysPath = 'keys.dat'

    BMConfigParser().read(keysPath)  # Read the keys.dat
    try:
        port = BMConfigParser().get('bitmessagesettings', 'port')
    except:
        print('\n     File not found.\n')
        usrPrompt = 0
        main()

    startonlogon = BMConfigParser().safeGetBoolean('bitmessagesettings', 'startonlogon')
    minimizetotray = BMConfigParser().safeGetBoolean('bitmessagesettings', 'minimizetotray')
    showtraynotifications = BMConfigParser().safeGetBoolean('bitmessagesettings', 'showtraynotifications')
    startintray = BMConfigParser().safeGetBoolean('bitmessagesettings', 'startintray')
    defaultnoncetrialsperbyte = BMConfigParser().get('bitmessagesettings', 'defaultnoncetrialsperbyte')
    defaultpayloadlengthextrabytes = BMConfigParser().get('bitmessagesettings', 'defaultpayloadlengthextrabytes')
    daemon = BMConfigParser().safeGetBoolean('bitmessagesettings', 'daemon')

    socksproxytype = BMConfigParser().get('bitmessagesettings', 'socksproxytype')
    sockshostname = BMConfigParser().get('bitmessagesettings', 'sockshostname')
    socksport = BMConfigParser().get('bitmessagesettings', 'socksport')
    socksauthentication = BMConfigParser().safeGetBoolean('bitmessagesettings', 'socksauthentication')
    socksusername = BMConfigParser().get('bitmessagesettings', 'socksusername')
    sockspassword = BMConfigParser().get('bitmessagesettings', 'sockspassword')

    print('\n     -----------------------------------')
    print('     |   Current Bitmessage Settings   |')
    print('     -----------------------------------')
    print('     port = ' + port)
    print('     startonlogon = ' + str(startonlogon))
    print('     minimizetotray = ' + str(minimizetotray))
    print('     showtraynotifications = ' + str(showtraynotifications))
    print('     startintray = ' + str(startintray))
    print('     defaultnoncetrialsperbyte = ' + defaultnoncetrialsperbyte)
    print('     defaultpayloadlengthextrabytes = ' + defaultpayloadlengthextrabytes)
    print('     daemon = ' + str(daemon))
    print('\n     ------------------------------------')
    print('     |   Current Connection Settings   |')
    print('     -----------------------------------')
    print('     socksproxytype = ' + socksproxytype)
    print('     sockshostname = ' + sockshostname)
    print('     socksport = ' + socksport)
    print('     socksauthentication = ' + str(socksauthentication))
    print('     socksusername = ' + socksusername)
    print('     sockspassword = ' + sockspassword)
    print(' ')

    uInput = userInput("Would you like to modify any of these settings, (Y)es or (N)o?").lower()

    if uInput == "y":
        while True:  # loops if they mistype the setting name, they can exit the loop with 'exit'
            invalidInput = False
            uInput = userInput("What setting would you like to modify?").lower()
            print(' ')

            if uInput == "port":
                print('     Current port number: ' + port)
                uInput = userInput("Enter the new port number.")
                BMConfigParser().set('bitmessagesettings', 'port', str(uInput))
            elif uInput == "startonlogon":
                print('     Current status: ' + str(startonlogon))
                uInput = userInput("Enter the new status.")
                BMConfigParser().set('bitmessagesettings', 'startonlogon', str(uInput))
            elif uInput == "minimizetotray":
                print('     Current status: ' + str(minimizetotray))
                uInput = userInput("Enter the new status.")
                BMConfigParser().set('bitmessagesettings', 'minimizetotray', str(uInput))
            elif uInput == "showtraynotifications":
                print('     Current status: ' + str(showtraynotifications))
                uInput = userInput("Enter the new status.")
                BMConfigParser().set('bitmessagesettings', 'showtraynotifications', str(uInput))
            elif uInput == "startintray":
                print('     Current status: ' + str(startintray))
                uInput = userInput("Enter the new status.")
                BMConfigParser().set('bitmessagesettings', 'startintray', str(uInput))
            elif uInput == "defaultnoncetrialsperbyte":
                print('     Current default nonce trials per byte: ' + defaultnoncetrialsperbyte)
                uInput = userInput("Enter the new defaultnoncetrialsperbyte.")
                BMConfigParser().set('bitmessagesettings', 'defaultnoncetrialsperbyte', str(uInput))
            elif uInput == "defaultpayloadlengthextrabytes":
                print('     Current default payload length extra bytes: ' + defaultpayloadlengthextrabytes)
                uInput = userInput("Enter the new defaultpayloadlengthextrabytes.")
                BMConfigParser().set('bitmessagesettings', 'defaultpayloadlengthextrabytes', str(uInput))
            elif uInput == "daemon":
                print('     Current status: ' + str(daemon))
                uInput = userInput("Enter the new status.").lower()
                BMConfigParser().set('bitmessagesettings', 'daemon', str(uInput))
            elif uInput == "socksproxytype":
                print('     Current socks proxy type: ' + socksproxytype)
                print("Possibilities: 'none', 'SOCKS4a', 'SOCKS5'.")
                uInput = userInput("Enter the new socksproxytype.")
                BMConfigParser().set('bitmessagesettings', 'socksproxytype', str(uInput))
            elif uInput == "sockshostname":
                print('     Current socks host name: ' + sockshostname)
                uInput = userInput("Enter the new sockshostname.")
                BMConfigParser().set('bitmessagesettings', 'sockshostname', str(uInput))
            elif uInput == "socksport":
                print('     Current socks port number: ' + socksport)
                uInput = userInput("Enter the new socksport.")
                BMConfigParser().set('bitmessagesettings', 'socksport', str(uInput))
            elif uInput == "socksauthentication":
                print('     Current status: ' + str(socksauthentication))
                uInput = userInput("Enter the new status.")
                BMConfigParser().set('bitmessagesettings', 'socksauthentication', str(uInput))
            elif uInput == "socksusername":
                print('     Current socks username: ' + socksusername)
                uInput = userInput("Enter the new socksusername.")
                BMConfigParser().set('bitmessagesettings', 'socksusername', str(uInput))
            elif uInput == "sockspassword":
                print('     Current socks password: ' + sockspassword)
                uInput = userInput("Enter the new password.")
                BMConfigParser().set('bitmessagesettings', 'sockspassword', str(uInput))
            else:
                print("\n     Invalid input. Please try again.\n")
                invalidInput = True

            if invalidInput is not True:  # don't prompt if they made a mistake.
                uInput = userInput("Would you like to change another setting, (Y)es or (N)o?").lower()

                if uInput != "y":
                    print('\n     Changes Made.\n')
                    with open(keysPath, 'wb') as configfile:
                        BMConfigParser().write(configfile)
                    restartBmNotify()
                    break

    elif uInput == "n":
        usrPrompt = 1
        main()
    else:
        print("Invalid input.")
        usrPrompt = 1
        main()


def validAddress(address):
    """Predicate to test address validity"""
    address_information = json.loads(api.decodeAddress(address))

    return 'success' in str(address_information['status']).lower()


def getAddress(passphrase, vNumber, sNumber):
    """Get a deterministic address"""
    passphrase = passphrase.encode('base64')  # passphrase must be encoded

    return api.getDeterministicAddress(passphrase, vNumber, sNumber)


def subscribe():
    """Subscribe to an address"""
    global usrPrompt

    while True:
        address = userInput("What address would you like to subscribe to?")

        if address == "c":
            usrPrompt = 1
            print(' ')
            main()
        elif validAddress(address) is False:
            print('\n     Invalid. "c" to cancel. Please try again.\n')
        else:
            break

    label = userInput("Enter a label for this address.")
    label = label.encode('base64')

    api.addSubscription(address, label)
    print('\n     You are now subscribed to: ' + address + '\n')


def unsubscribe():
    """Unsusbcribe from an address"""
    global usrPrompt

    while True:
        address = userInput("What address would you like to unsubscribe from?")

        if address == "c":
            usrPrompt = 1
            print(' ')
            main()
        elif validAddress(address) is False:
            print('\n     Invalid. "c" to cancel. Please try again.\n')
        else:
            break

    userInput("Are you sure, (Y)es or (N)o?").lower()  # uInput =

    api.deleteSubscription(address)
    print('\n     You are now unsubscribed from: ' + address + '\n')


def listSubscriptions():
    """List subscriptions"""

    global usrPrompt
    print('\nLabel, Address, Enabled\n')
    try:
        print(api.listSubscriptions())
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()
    print(' ')


def createChan():
    """Create a channel"""

    global usrPrompt
    password = userInput("Enter channel name")
    password = password.encode('base64')
    try:
        print(api.createChan(password))
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()


def joinChan():
    """Join a channel"""

    global usrPrompt
    while True:
        address = userInput("Enter channel address")

        if address == "c":
            usrPrompt = 1
            print(' ')
            main()
        elif validAddress(address) is False:
            print('\n     Invalid. "c" to cancel. Please try again.\n')
        else:
            break

    password = userInput("Enter channel name")
    password = password.encode('base64')
    try:
        print(api.joinChan(password, address))
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()


def leaveChan():
    """Leave a channel"""

    global usrPrompt
    while True:
        address = userInput("Enter channel address")

        if address == "c":
            usrPrompt = 1
            print(' ')
            main()
        elif validAddress(address) is False:
            print('\n     Invalid. "c" to cancel. Please try again.\n')
        else:
            break

    try:
        print(api.leaveChan(address))
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()


def listAdd():
    """List all of the addresses and their info"""
    global usrPrompt
    try:
        jsonAddresses = json.loads(api.listAddresses())
        numAddresses = len(jsonAddresses['addresses'])  # Number of addresses
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()

    # print('\nAddress Number,Label,Address,Stream,Enabled\n')
    print('\n     --------------------------------------------------------------------------')
    print('     | # |       Label       |               Address               |S#|Enabled|')
    print('     |---|-------------------|-------------------------------------|--|-------|')
    for addNum in range(0, numAddresses):  # processes all of the addresses and lists them out
        label = (jsonAddresses['addresses'][addNum]['label']).encode(
            'utf')              # may still misdiplay in some consoles
        address = str(jsonAddresses['addresses'][addNum]['address'])
        stream = str(jsonAddresses['addresses'][addNum]['stream'])
        enabled = str(jsonAddresses['addresses'][addNum]['enabled'])

        if len(label) > 19:
            label = label[:16] + '...'

        print(''.join([
            '     |',
            str(addNum).ljust(3),
            '|',
            label.ljust(19),
            '|',
            address.ljust(37),
            '|',
            stream.ljust(1),
            '|',
            enabled.ljust(7),
            '|',
        ]))

    print(''.join([
        '     ',
        74 * '-',
        '\n',
    ]))


def genAdd(lbl, deterministic, passphrase, numOfAdd, addVNum, streamNum, ripe):
    """Generate address"""

    global usrPrompt

    if deterministic is False:  # Generates a new address with the user defined label. non-deterministic
        addressLabel = lbl.encode('base64')
        try:
            generatedAddress = api.createRandomAddress(addressLabel)
        except:
            print('\n     Connection Error\n')
            usrPrompt = 0
            main()

        return generatedAddress

    elif deterministic:  # Generates a new deterministic address with the user inputs.
        passphrase = passphrase.encode('base64')
        try:
            generatedAddress = api.createDeterministicAddresses(passphrase, numOfAdd, addVNum, streamNum, ripe)
        except:
            print('\n     Connection Error\n')
            usrPrompt = 0
            main()
        return generatedAddress

    return 'Entry Error'


def saveFile(fileName, fileData):
    """Allows attachments and messages/broadcats to be saved"""

    # This section finds all invalid characters and replaces them with ~
    fileName = fileName.replace(" ", "")
    fileName = fileName.replace("/", "~")
    # fileName = fileName.replace("\\", "~") How do I get this to work...?
    fileName = fileName.replace(":", "~")
    fileName = fileName.replace("*", "~")
    fileName = fileName.replace("?", "~")
    fileName = fileName.replace('"', "~")
    fileName = fileName.replace("<", "~")
    fileName = fileName.replace(">", "~")
    fileName = fileName.replace("|", "~")

    directory = os.path.abspath('attachments')

    if not os.path.exists(directory):
        os.makedirs(directory)

    filePath = os.path.join(directory, fileName)

    with open(filePath, 'wb+') as path_to_file:
        path_to_file.write(fileData.decode("base64"))
    print('\n     Successfully saved ' + filePath + '\n')


def attachment():
    """Allows users to attach a file to their message or broadcast"""

    theAttachmentS = ''

    while True:

        isImage = False
        theAttachment = ''

        while True:  # loops until valid path is entered
            filePath = userInput(
                '\nPlease enter the path to the attachment or just the attachment name if in this folder.')

            try:
                with open(filePath):
                    break
            except IOError:
                print('\n     %s was not found on your filesystem or can not be opened.\n' % filePath)

        # print(filesize, and encoding estimate with confirmation if file is over X size (1mb?))
        invSize = os.path.getsize(filePath)
        invSize = (invSize / 1024)  # Converts to kilobytes
        round(invSize, 2)  # Rounds to two decimal places

        if invSize > 500.0:  # If over 500KB
            print(''.join([
                '\n     WARNING:The file that you are trying to attach is ',
                invSize,
                'KB and will take considerable time to send.\n'
            ]))
            uInput = userInput('Are you sure you still want to attach it, (Y)es or (N)o?').lower()

            if uInput != "y":
                print('\n     Attachment discarded.\n')
                return ''
        elif invSize > 184320.0:  # If larger than 180MB, discard.
            print('\n     Attachment too big, maximum allowed size:180MB\n')
            main()

        pathLen = len(str(ntpath.basename(filePath)))  # Gets the length of the filepath excluding the filename
        fileName = filePath[(len(str(filePath)) - pathLen):]  # reads the filename

        filetype = imghdr.what(filePath)  # Tests if it is an image file
        if filetype is not None:
            print('\n     ---------------------------------------------------')
            print('     Attachment detected as an Image.')
            print('     <img> tags will automatically be included,')
            print('     allowing the recipient to view the image')
            print('     using the "View HTML code..." option in Bitmessage.')
            print('     ---------------------------------------------------\n')
            isImage = True
            time.sleep(2)

        # Alert the user that the encoding process may take some time.
        print('\n     Encoding Attachment, Please Wait ...\n')

        with open(filePath, 'rb') as f:  # Begin the actual encoding
            data = f.read(188743680)  # Reads files up to 180MB, the maximum size for Bitmessage.
            data = data.encode("base64")

        if isImage:  # If it is an image, include image tags in the message
            theAttachment = """
<!-- Note: Image attachment below. Please use the right click "View HTML code ..." option to view it. -->
<!-- Sent using Bitmessage Daemon. https://github.com/Dokument/PyBitmessage-Daemon -->

Filename:%s
Filesize:%sKB
Encoding:base64

<center>
    <div id="image">
        <img alt = "%s" src='data:image/%s;base64, %s' />
    </div>
</center>""" % (fileName, invSize, fileName, filetype, data)
        else:  # Else it is not an image so do not include the embedded image code.
            theAttachment = """
<!-- Note: File attachment below. Please use a base64 decoder, or Daemon, to save it. -->
<!-- Sent using Bitmessage Daemon. https://github.com/Dokument/PyBitmessage-Daemon -->

Filename:%s
Filesize:%sKB
Encoding:base64

<attachment alt = "%s" src='data:file/%s;base64, %s' />""" % (fileName, invSize, fileName, fileName, data)

        uInput = userInput('Would you like to add another attachment, (Y)es or (N)o?').lower()

        if uInput == 'y' or uInput == 'yes':  # Allows multiple attachments to be added to one message
            theAttachmentS = str(theAttachmentS) + str(theAttachment) + '\n\n'
        elif uInput == 'n' or uInput == 'no':
            break

    theAttachmentS = theAttachmentS + theAttachment
    return theAttachmentS


def sendMsg(toAddress, fromAddress, subject, message):
    """
    With no arguments sent, sendMsg fills in the blanks.
    subject and message must be encoded before they are passed.
    """

    global usrPrompt
    if validAddress(toAddress) is False:
        while True:
            toAddress = userInput("What is the To Address?")

            if toAddress == "c":
                usrPrompt = 1
                print(' ')
                main()
            elif validAddress(toAddress) is False:
                print('\n     Invalid Address. "c" to cancel. Please try again.\n')
            else:
                break

    if validAddress(fromAddress) is False:
        try:
            jsonAddresses = json.loads(api.listAddresses())
            numAddresses = len(jsonAddresses['addresses'])  # Number of addresses
        except:
            print('\n     Connection Error\n')
            usrPrompt = 0
            main()

        if numAddresses > 1:  # Ask what address to send from if multiple addresses
            found = False
            while True:
                print(' ')
                fromAddress = userInput("Enter an Address or Address Label to send from.")

                if fromAddress == "exit":
                    usrPrompt = 1
                    main()

                for addNum in range(0, numAddresses):  # processes all of the addresses
                    label = jsonAddresses['addresses'][addNum]['label']
                    address = jsonAddresses['addresses'][addNum]['address']
                    if fromAddress == label:  # address entered was a label and is found
                        fromAddress = address
                        found = True
                        break

                if found is False:
                    if validAddress(fromAddress) is False:
                        print('\n     Invalid Address. Please try again.\n')

                    else:
                        for addNum in range(0, numAddresses):  # processes all of the addresses
                            address = jsonAddresses['addresses'][addNum]['address']
                            if fromAddress == address:  # address entered was a found in our addressbook.
                                found = True
                                break

                        if found is False:
                            print('\n     The address entered is not one of yours. Please try again.\n')

                if found:
                    break  # Address was found

        else:  # Only one address in address book
            print('\n     Using the only address in the addressbook to send from.\n')
            fromAddress = jsonAddresses['addresses'][0]['address']

    if subject == '':
        subject = userInput("Enter your Subject.")
        subject = subject.encode('base64')
    if message == '':
        message = userInput("Enter your Message.")

        uInput = userInput('Would you like to add an attachment, (Y)es or (N)o?').lower()
        if uInput == "y":
            message = message + '\n\n' + attachment()

        message = message.encode('base64')

    try:
        ackData = api.sendMessage(toAddress, fromAddress, subject, message)
        print('\n     Message Status:', api.getStatus(ackData), '\n')
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()


def sendBrd(fromAddress, subject, message):
    """Send a broadcast"""

    global usrPrompt
    if fromAddress == '':

        try:
            jsonAddresses = json.loads(api.listAddresses())
            numAddresses = len(jsonAddresses['addresses'])  # Number of addresses
        except:
            print('\n     Connection Error\n')
            usrPrompt = 0
            main()

        if numAddresses > 1:  # Ask what address to send from if multiple addresses
            found = False
            while True:
                fromAddress = userInput("\nEnter an Address or Address Label to send from.")

                if fromAddress == "exit":
                    usrPrompt = 1
                    main()

                for addNum in range(0, numAddresses):  # processes all of the addresses
                    label = jsonAddresses['addresses'][addNum]['label']
                    address = jsonAddresses['addresses'][addNum]['address']
                    if fromAddress == label:  # address entered was a label and is found
                        fromAddress = address
                        found = True
                        break

                if found is False:
                    if validAddress(fromAddress) is False:
                        print('\n     Invalid Address. Please try again.\n')

                    else:
                        for addNum in range(0, numAddresses):  # processes all of the addresses
                            address = jsonAddresses['addresses'][addNum]['address']
                            if fromAddress == address:  # address entered was a found in our addressbook.
                                found = True
                                break

                        if found is False:
                            print('\n     The address entered is not one of yours. Please try again.\n')

                if found:
                    break  # Address was found

        else:  # Only one address in address book
            print('\n     Using the only address in the addressbook to send from.\n')
            fromAddress = jsonAddresses['addresses'][0]['address']

    if subject == '':
        subject = userInput("Enter your Subject.")
        subject = subject.encode('base64')
    if message == '':
        message = userInput("Enter your Message.")

        uInput = userInput('Would you like to add an attachment, (Y)es or (N)o?').lower()
        if uInput == "y":
            message = message + '\n\n' + attachment()

        message = message.encode('base64')

    try:
        ackData = api.sendBroadcast(fromAddress, subject, message)
        print('\n     Message Status:', api.getStatus(ackData), '\n')
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()


def inbox(unreadOnly=False):
    """Lists the messages by: Message Number, To Address Label, From Address Label, Subject, Received Time)"""

    global usrPrompt
    try:
        inboxMessages = json.loads(api.getAllInboxMessages())
        numMessages = len(inboxMessages['inboxMessages'])
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()

    messagesPrinted = 0
    messagesUnread = 0
    for msgNum in range(0, numMessages):  # processes all of the messages in the inbox
        message = inboxMessages['inboxMessages'][msgNum]
        # if we are displaying all messages or if this message is unread then display it
        if not unreadOnly or not message['read']:
            print('     -----------------------------------\n')
            print('     Message Number:', msgNum)  # Message Number
            print('     To:', getLabelForAddress(message['toAddress']))  # Get the to address
            print('     From:', getLabelForAddress(message['fromAddress']))  # Get the from address
            print('     Subject:', message['subject'].decode('base64'))  # Get the subject
            print(''.join([
                '     Received:',
                datetime.datetime.fromtimestamp(
                    float(message['receivedTime'])).strftime('%Y-%m-%d %H:%M:%S'),
            ]))
            messagesPrinted += 1
            if not message['read']:
                messagesUnread += 1

        if messagesPrinted % 20 == 0 and messagesPrinted != 0:
            userInput('(Press Enter to continue or type (Exit) to return to the main menu.)').lower()  # uInput =

    print('\n     -----------------------------------')
    print('     There are %d unread messages of %d messages in the inbox.' % (messagesUnread, numMessages))
    print('     -----------------------------------\n')


def outbox():
    """TBC"""

    global usrPrompt
    try:
        outboxMessages = json.loads(api.getAllSentMessages())
        numMessages = len(outboxMessages['sentMessages'])
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()

    for msgNum in range(0, numMessages):  # processes all of the messages in the outbox
        print('\n     -----------------------------------\n')
        print('     Message Number:', msgNum)  # Message Number
        # print('     Message ID:', outboxMessages['sentMessages'][msgNum]['msgid'])
        # Get the to address
        print('     To:', getLabelForAddress(outboxMessages['sentMessages'][msgNum]['toAddress']))
        # Get the from address
        print('     From:', getLabelForAddress(outboxMessages['sentMessages'][msgNum]['fromAddress']))
        print('     Subject:', outboxMessages['sentMessages'][msgNum]['subject'].decode('base64'))  # Get the subject
        print('     Status:', outboxMessages['sentMessages'][msgNum]['status'])  # Get the subject
        print(''.join([
            '     Last Action Time:',
            datetime.datetime.fromtimestamp(
                float(outboxMessages['sentMessages'][msgNum]['lastActionTime'])).strftime('%Y-%m-%d %H:%M:%S'),
        ]))

        if msgNum % 20 == 0 and msgNum != 0:
            userInput('(Press Enter to continue or type (Exit) to return to the main menu.)').lower()  # uInput =

    print('\n     -----------------------------------')
    print('     There are ', numMessages, ' messages in the outbox.')
    print('     -----------------------------------\n')


def readSentMsg(msgNum):
    """Opens a sent message for reading"""

    global usrPrompt
    try:
        outboxMessages = json.loads(api.getAllSentMessages())
        numMessages = len(outboxMessages['sentMessages'])
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()

    print(' ')

    if msgNum >= numMessages:
        print('\n     Invalid Message Number.\n')
        main()

    # Begin attachment detection
    message = outboxMessages['sentMessages'][msgNum]['message'].decode('base64')

    while True:  # Allows multiple messages to be downloaded/saved
        if ';base64,' in message:  # Found this text in the message, there is probably an attachment.
            attPos = message.index(";base64,")  # Finds the attachment position
            attEndPos = message.index("' />")  # Finds the end of the attachment
            # attLen = attEndPos - attPos #Finds the length of the message

            if 'alt = "' in message:  # We can get the filename too
                fnPos = message.index('alt = "')  # Finds position of the filename
                fnEndPos = message.index('" src=')  # Finds the end position
                # fnLen = fnEndPos - fnPos #Finds the length of the filename

                fileName = message[fnPos + 7:fnEndPos]
            else:
                fnPos = attPos
                fileName = 'Attachment'

            uInput = userInput(
                '\n     Attachment Detected. Would you like to save the attachment, (Y)es or (N)o?').lower()
            if uInput == "y" or uInput == 'yes':

                this_attachment = message[attPos + 9:attEndPos]
                saveFile(fileName, this_attachment)

            message = message[:fnPos] + '~<Attachment data removed for easier viewing>~' + message[(attEndPos + 4):]

        else:
            break

    # End attachment Detection

    print('\n     To:', getLabelForAddress(outboxMessages['sentMessages'][msgNum]['toAddress']))  # Get the to address
    # Get the from address
    print('     From:', getLabelForAddress(outboxMessages['sentMessages'][msgNum]['fromAddress']))
    print('     Subject:', outboxMessages['sentMessages'][msgNum]['subject'].decode('base64'))  # Get the subject
    print('     Status:', outboxMessages['sentMessages'][msgNum]['status'])  # Get the subject
    print(''.join([
        '     Last Action Time:',
        datetime.datetime.fromtimestamp(
            float(outboxMessages['sentMessages'][msgNum]['lastActionTime'])).strftime('%Y-%m-%d %H:%M:%S'),
    ]))
    print('     Message:\n')
    print(message)  # inboxMessages['inboxMessages'][msgNum]['message'].decode('base64')
    print(' ')


def readMsg(msgNum):
    """Open a message for reading"""
    global usrPrompt
    try:
        inboxMessages = json.loads(api.getAllInboxMessages())
        numMessages = len(inboxMessages['inboxMessages'])
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()

    if msgNum >= numMessages:
        print('\n     Invalid Message Number.\n')
        main()

    # Begin attachment detection
    message = inboxMessages['inboxMessages'][msgNum]['message'].decode('base64')

    while True:  # Allows multiple messages to be downloaded/saved
        if ';base64,' in message:  # Found this text in the message, there is probably an attachment.
            attPos = message.index(";base64,")  # Finds the attachment position
            attEndPos = message.index("' />")  # Finds the end of the attachment
            # attLen = attEndPos - attPos #Finds the length of the message

            if 'alt = "' in message:  # We can get the filename too
                fnPos = message.index('alt = "')  # Finds position of the filename
                fnEndPos = message.index('" src=')  # Finds the end position
                # fnLen = fnEndPos - fnPos #Finds the length of the filename

                fileName = message[fnPos + 7:fnEndPos]
            else:
                fnPos = attPos
                fileName = 'Attachment'

            uInput = userInput(
                '\n     Attachment Detected. Would you like to save the attachment, (Y)es or (N)o?').lower()
            if uInput == "y" or uInput == 'yes':

                this_attachment = message[attPos + 9:attEndPos]
                saveFile(fileName, this_attachment)

            message = message[:fnPos] + '~<Attachment data removed for easier viewing>~' + message[attEndPos + 4:]

        else:
            break

    # End attachment Detection
    print('\n     To:', getLabelForAddress(inboxMessages['inboxMessages'][msgNum]['toAddress']))  # Get the to address
    # Get the from address
    print('     From:', getLabelForAddress(inboxMessages['inboxMessages'][msgNum]['fromAddress']))
    print('     Subject:', inboxMessages['inboxMessages'][msgNum]['subject'].decode('base64'))  # Get the subject
    print(''.join([
        '     Received:', datetime.datetime.fromtimestamp(
            float(inboxMessages['inboxMessages'][msgNum]['receivedTime'])).strftime('%Y-%m-%d %H:%M:%S'),
    ]))
    print('     Message:\n')
    print(message)  # inboxMessages['inboxMessages'][msgNum]['message'].decode('base64')
    print(' ')
    return inboxMessages['inboxMessages'][msgNum]['msgid']


def replyMsg(msgNum, forwardORreply):
    """Allows you to reply to the message you are currently on. Saves typing in the addresses and subject."""

    global usrPrompt
    forwardORreply = forwardORreply.lower()  # makes it lowercase
    try:
        inboxMessages = json.loads(api.getAllInboxMessages())
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()

    fromAdd = inboxMessages['inboxMessages'][msgNum]['toAddress']  # Address it was sent To, now the From address
    message = inboxMessages['inboxMessages'][msgNum]['message'].decode('base64')  # Message that you are replying too.

    subject = inboxMessages['inboxMessages'][msgNum]['subject']
    subject = subject.decode('base64')

    if forwardORreply == 'reply':
        toAdd = inboxMessages['inboxMessages'][msgNum]['fromAddress']  # Address it was From, now the To address
        subject = "Re: " + subject

    elif forwardORreply == 'forward':
        subject = "Fwd: " + subject

        while True:
            toAdd = userInput("What is the To Address?")

            if toAdd == "c":
                usrPrompt = 1
                print(' ')
                main()
            elif validAddress(toAdd) is False:
                print('\n     Invalid Address. "c" to cancel. Please try again.\n')
            else:
                break
    else:
        print('\n     Invalid Selection. Reply or Forward only')
        usrPrompt = 0
        main()

    subject = subject.encode('base64')

    newMessage = userInput("Enter your Message.")

    uInput = userInput('Would you like to add an attachment, (Y)es or (N)o?').lower()
    if uInput == "y":
        newMessage = newMessage + '\n\n' + attachment()

    newMessage = newMessage + '\n\n------------------------------------------------------\n'
    newMessage = newMessage + message
    newMessage = newMessage.encode('base64')

    sendMsg(toAdd, fromAdd, subject, newMessage)

    main()


def delMsg(msgNum):
    """Deletes a specified message from the inbox"""

    global usrPrompt
    try:
        inboxMessages = json.loads(api.getAllInboxMessages())
        # gets the message ID via the message index number
        msgId = inboxMessages['inboxMessages'][int(msgNum)]['msgid']

        msgAck = api.trashMessage(msgId)
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()

    return msgAck


def delSentMsg(msgNum):
    """Deletes a specified message from the outbox"""

    global usrPrompt
    try:
        outboxMessages = json.loads(api.getAllSentMessages())
        # gets the message ID via the message index number
        msgId = outboxMessages['sentMessages'][int(msgNum)]['msgid']
        msgAck = api.trashSentMessage(msgId)
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()

    return msgAck


def getLabelForAddress(address):
    """Get label for an address"""

    if address in knownAddresses:
        return knownAddresses[address]
    else:
        buildKnownAddresses()
        if address in knownAddresses:
            return knownAddresses[address]

    return address


def buildKnownAddresses():
    """Build known addresses"""

    global usrPrompt

    # add from address book
    try:
        response = api.listAddressBookEntries()
        # if api is too old then fail
        if "API Error 0020" in response:
            return
        addressBook = json.loads(response)
        for entry in addressBook['addresses']:
            if entry['address'] not in knownAddresses:
                knownAddresses[entry['address']] = "%s (%s)" % (entry['label'].decode('base64'), entry['address'])
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()

    # add from my addresses
    try:
        response = api.listAddresses2()
        # if api is too old just return then fail
        if "API Error 0020" in response:
            return
        addresses = json.loads(response)
        for entry in addresses['addresses']:
            if entry['address'] not in knownAddresses:
                knownAddresses[entry['address']] = "%s (%s)" % (entry['label'].decode('base64'), entry['address'])
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()


def listAddressBookEntries():
    """List addressbook entries"""

    global usrPrompt

    try:
        response = api.listAddressBookEntries()
        if "API Error" in response:
            return getAPIErrorCode(response)
        addressBook = json.loads(response)
        print()
        print('     --------------------------------------------------------------')
        print('     |        Label       |                Address                |')
        print('     |--------------------|---------------------------------------|')
        for entry in addressBook['addresses']:
            label = entry['label'].decode('base64')
            address = entry['address']
            if len(label) > 19:
                label = label[:16] + '...'
            print('     | ' + label.ljust(19) + '| ' + address.ljust(37) + ' |')
        print('     --------------------------------------------------------------')
        print()
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()


def addAddressToAddressBook(address, label):
    """Add an address to an addressbook"""

    global usrPrompt

    try:
        response = api.addAddressBookEntry(address, label.encode('base64'))
        if "API Error" in response:
            return getAPIErrorCode(response)
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()


def deleteAddressFromAddressBook(address):
    """Delete an address from an addressbook"""

    global usrPrompt

    try:
        response = api.deleteAddressBookEntry(address)
        if "API Error" in response:
            return getAPIErrorCode(response)
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()


def getAPIErrorCode(response):
    """Get API error code"""

    if "API Error" in response:
        # if we got an API error return the number by getting the number
        # after the second space and removing the trailing colon
        return int(response.split()[2][:-1])


def markMessageRead(messageID):
    """Mark a message as read"""

    global usrPrompt

    try:
        response = api.getInboxMessageByID(messageID, True)
        if "API Error" in response:
            return getAPIErrorCode(response)
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()


def markMessageUnread(messageID):
    """Mark a mesasge as unread"""

    global usrPrompt

    try:
        response = api.getInboxMessageByID(messageID, False)
        if "API Error" in response:
            return getAPIErrorCode(response)
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()


def markAllMessagesRead():
    """Mark all messages as read"""

    global usrPrompt

    try:
        inboxMessages = json.loads(api.getAllInboxMessages())['inboxMessages']
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()
    for message in inboxMessages:
        if not message['read']:
            markMessageRead(message['msgid'])


def markAllMessagesUnread():
    """Mark all messages as unread"""

    global usrPrompt

    try:
        inboxMessages = json.loads(api.getAllInboxMessages())['inboxMessages']
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()
    for message in inboxMessages:
        if message['read']:
            markMessageUnread(message['msgid'])


def clientStatus():
    """Print the client status"""

    global usrPrompt

    try:
        client_status = json.loads(api.clientStatus())
    except:
        print('\n     Connection Error\n')
        usrPrompt = 0
        main()

    print("\nnetworkStatus: " + client_status['networkStatus'] + "\n")
    print("\nnetworkConnections: " + str(client_status['networkConnections']) + "\n")
    print("\nnumberOfPubkeysProcessed: " + str(client_status['numberOfPubkeysProcessed']) + "\n")
    print("\nnumberOfMessagesProcessed: " + str(client_status['numberOfMessagesProcessed']) + "\n")
    print("\nnumberOfBroadcastsProcessed: " + str(client_status['numberOfBroadcastsProcessed']) + "\n")


def shutdown():
    """Shutdown the API"""

    try:
        api.shutdown()
    except socket.error:
        pass
    print("\nShutdown command relayed\n")


def UI(usrInput):
    """Main user menu"""

    global usrPrompt

    if usrInput == "help" or usrInput == "h" or usrInput == "?":
        print(' ')
        print('     -------------------------------------------------------------------------')
        print('     |        https://github.com/Dokument/PyBitmessage-Daemon                |')
        print('     |-----------------------------------------------------------------------|')
        print('     | Command                | Description                                  |')
        print('     |------------------------|----------------------------------------------|')
        print('     | help                   | This help file.                              |')
        print('     | apiTest                | Tests the API                                |')
        print('     | addInfo                | Returns address information (If valid)       |')
        print('     | bmSettings             | BitMessage settings                          |')
        print('     | exit                   | Use anytime to return to main menu           |')
        print('     | quit                   | Quits the program                            |')
        print('     |------------------------|----------------------------------------------|')
        print('     | listAddresses          | Lists all of the users addresses             |')
        print('     | generateAddress        | Generates a new address                      |')
        print('     | getAddress             | Get determinist address from passphrase      |')
        print('     |------------------------|----------------------------------------------|')
        print('     | listAddressBookEntries | Lists entries from the Address Book          |')
        print('     | addAddressBookEntry    | Add address to the Address Book              |')
        print('     | deleteAddressBookEntry | Deletes address from the Address Book        |')
        print('     |------------------------|----------------------------------------------|')
        print('     | subscribe              | Subscribes to an address                     |')
        print('     | unsubscribe            | Unsubscribes from an address                 |')
        print('     |------------------------|----------------------------------------------|')
        print('     | create                 | Creates a channel                            |')
        print('     | join                   | Joins a channel                              |')
        print('     | leave                  | Leaves a channel                             |')
        print('     |------------------------|----------------------------------------------|')
        print('     | inbox                  | Lists the message information for the inbox  |')
        print('     | outbox                 | Lists the message information for the outbox |')
        print('     | send                   | Send a new message or broadcast              |')
        print('     | unread                 | Lists all unread inbox messages              |')
        print('     | read                   | Reads a message from the inbox or outbox     |')
        print('     | save                   | Saves message to text file                   |')
        print('     | delete                 | Deletes a message or all messages            |')
        print('     -------------------------------------------------------------------------')
        print(' ')
        main()

    elif usrInput == "apitest":  # tests the API Connection.
        if apiTest():
            print('\n     API connection test has: PASSED\n')
        else:
            print('\n     API connection test has: FAILED\n')
        main()

    elif usrInput == "addinfo":
        tmp_address = userInput('\nEnter the Bitmessage Address.')
        address_information = json.loads(api.decodeAddress(tmp_address))

        print('\n------------------------------')

        if 'success' in str(address_information['status']).lower():
            print(' Valid Address')
            print(' Address Version: %s' % str(address_information['addressVersion']))
            print(' Stream Number: %s' % str(address_information['streamNumber']))
        else:
            print(' Invalid Address !')

        print('------------------------------\n')
        main()

    elif usrInput == "bmsettings":  # tests the API Connection.
        bmSettings()
        print(' ')
        main()

    elif usrInput == "quit":  # Quits the application
        print('\n     Bye\n')
        sys.exit(0)

    elif usrInput == "listaddresses":  # Lists all of the identities in the addressbook
        listAdd()
        main()

    elif usrInput == "generateaddress":  # Generates a new address
        uInput = userInput('\nWould you like to create a (D)eterministic or (R)andom address?').lower()

        if uInput in ["d", "deterministic"]:  # Creates a deterministic address
            deterministic = True

            lbl = ''
            passphrase = userInput('Enter the Passphrase.')  # .encode('base64')
            numOfAdd = int(userInput('How many addresses would you like to generate?'))
            addVNum = 3
            streamNum = 1
            isRipe = userInput('Shorten the address, (Y)es or (N)o?').lower()

            if isRipe == "y":
                ripe = True
                print(genAdd(lbl, deterministic, passphrase, numOfAdd, addVNum, streamNum, ripe))
                main()
            elif isRipe == "n":
                ripe = False
                print(genAdd(lbl, deterministic, passphrase, numOfAdd, addVNum, streamNum, ripe))
                main()
            elif isRipe == "exit":
                usrPrompt = 1
                main()
            else:
                print('\n     Invalid input\n')
                main()

        elif uInput == "r" or uInput == "random":  # Creates a random address with user-defined label
            deterministic = False
            null = ''
            lbl = userInput('Enter the label for the new address.')

            print(genAdd(lbl, deterministic, null, null, null, null, null))
            main()

        else:
            print('\n     Invalid input\n')
            main()

    elif usrInput == "getaddress":  # Gets the address for/from a passphrase
        phrase = userInput("Enter the address passphrase.")
        print('\n     Working...\n')
        address = getAddress(phrase, 4, 1)  # ,vNumber,sNumber)
        print('\n     Address: ' + address + '\n')
        usrPrompt = 1
        main()

    elif usrInput == "subscribe":  # Subsribe to an address
        subscribe()
        usrPrompt = 1
        main()

    elif usrInput == "unsubscribe":  # Unsubscribe from an address
        unsubscribe()
        usrPrompt = 1
        main()

    elif usrInput == "listsubscriptions":  # Unsubscribe from an address
        listSubscriptions()
        usrPrompt = 1
        main()

    elif usrInput == "create":
        createChan()
        usrPrompt = 1
        main()

    elif usrInput == "join":
        joinChan()
        usrPrompt = 1
        main()

    elif usrInput == "leave":
        leaveChan()
        usrPrompt = 1
        main()

    elif usrInput == "inbox":
        print('\n     Loading...\n')
        inbox()
        main()

    elif usrInput == "unread":
        print('\n     Loading...\n')
        inbox(True)
        main()

    elif usrInput == "outbox":
        print('\n     Loading...\n')
        outbox()
        main()

    elif usrInput == 'send':  # Sends a message or broadcast
        uInput = userInput('Would you like to send a (M)essage or (B)roadcast?').lower()

        if (uInput == 'm' or uInput == 'message'):
            null = ''
            sendMsg(null, null, null, null)
            main()
        elif (uInput == 'b' or uInput == 'broadcast'):
            null = ''
            sendBrd(null, null, null)
            main()

    elif usrInput == "read":  # Opens a message from the inbox for viewing.

        uInput = userInput("Would you like to read a message from the (I)nbox or (O)utbox?").lower()

        if (uInput != 'i' and uInput != 'inbox' and uInput != 'o' and uInput != 'outbox'):
            print('\n     Invalid Input.\n')
            usrPrompt = 1
            main()

        msgNum = int(userInput("What is the number of the message you wish to open?"))

        if (uInput == 'i' or uInput == 'inbox'):
            print('\n     Loading...\n')
            messageID = readMsg(msgNum)

            uInput = userInput("\nWould you like to keep this message unread, (Y)es or (N)o?").lower()

            if not (uInput == 'y' or uInput == 'yes'):
                markMessageRead(messageID)
                usrPrompt = 1

            uInput = userInput("\nWould you like to (D)elete, (F)orward, (R)eply to, or (Exit) this message?").lower()

            if uInput in ['r', 'reply']:
                print('\n     Loading...\n')
                print(' ')
                replyMsg(msgNum, 'reply')
                usrPrompt = 1

            elif uInput == 'f' or uInput == 'forward':
                print('\n     Loading...\n')
                print(' ')
                replyMsg(msgNum, 'forward')
                usrPrompt = 1

            elif uInput in ["d", 'delete']:
                uInput = userInput("Are you sure, (Y)es or (N)o?").lower()  # Prevent accidental deletion

                if uInput == "y":
                    delMsg(msgNum)
                    print('\n     Message Deleted.\n')
                    usrPrompt = 1
                else:
                    usrPrompt = 1
            else:
                print('\n     Invalid entry\n')
                usrPrompt = 1

        elif (uInput == 'o' or uInput == 'outbox'):
            readSentMsg(msgNum)

            # Gives the user the option to delete the message
            uInput = userInput("Would you like to (D)elete, or (Exit) this message?").lower()

            if (uInput == "d" or uInput == 'delete'):
                uInput = userInput('Are you sure, (Y)es or (N)o?').lower()  # Prevent accidental deletion

                if uInput == "y":
                    delSentMsg(msgNum)
                    print('\n     Message Deleted.\n')
                    usrPrompt = 1
                else:
                    usrPrompt = 1
            else:
                print('\n     Invalid Entry\n')
                usrPrompt = 1

        main()

    elif usrInput == "save":

        uInput = userInput("Would you like to save a message from the (I)nbox or (O)utbox?").lower()

        if uInput not in ['i', 'inbox', 'o', 'outbox']:
            print('\n     Invalid Input.\n')
            usrPrompt = 1
            main()

        if uInput in ['i', 'inbox']:
            inboxMessages = json.loads(api.getAllInboxMessages())
            numMessages = len(inboxMessages['inboxMessages'])

            while True:
                msgNum = int(userInput("What is the number of the message you wish to save?"))

                if msgNum >= numMessages:
                    print('\n     Invalid Message Number.\n')
                else:
                    break

            subject = inboxMessages['inboxMessages'][msgNum]['subject'].decode('base64')
            # Don't decode since it is done in the saveFile function
            message = inboxMessages['inboxMessages'][msgNum]['message']

        elif uInput == 'o' or uInput == 'outbox':
            outboxMessages = json.loads(api.getAllSentMessages())
            numMessages = len(outboxMessages['sentMessages'])

            while True:
                msgNum = int(userInput("What is the number of the message you wish to save?"))

                if msgNum >= numMessages:
                    print('\n     Invalid Message Number.\n')
                else:
                    break

            subject = outboxMessages['sentMessages'][msgNum]['subject'].decode('base64')
            # Don't decode since it is done in the saveFile function
            message = outboxMessages['sentMessages'][msgNum]['message']

        subject = subject + '.txt'
        saveFile(subject, message)

        usrPrompt = 1
        main()

    elif usrInput == "delete":  # will delete a message from the system, not reflected on the UI.

        uInput = userInput("Would you like to delete a message from the (I)nbox or (O)utbox?").lower()

        if uInput in ['i', 'inbox']:
            inboxMessages = json.loads(api.getAllInboxMessages())
            numMessages = len(inboxMessages['inboxMessages'])

            while True:
                msgNum = userInput(
                    'Enter the number of the message you wish to delete or (A)ll to empty the inbox.').lower()

                if msgNum == 'a' or msgNum == 'all':
                    break
                elif int(msgNum) >= numMessages:
                    print('\n     Invalid Message Number.\n')
                else:
                    break

            uInput = userInput("Are you sure, (Y)es or (N)o?").lower()  # Prevent accidental deletion

            if uInput == "y":
                if msgNum in ['a', 'all']:
                    print(' ')
                    for msgNum in range(0, numMessages):  # processes all of the messages in the inbox
                        print('     Deleting message ', msgNum + 1, ' of ', numMessages)
                        delMsg(0)

                    print('\n     Inbox is empty.')
                    usrPrompt = 1
                else:
                    delMsg(int(msgNum))

                print('\n     Notice: Message numbers may have changed.\n')
                main()
            else:
                usrPrompt = 1

        elif uInput in ['o', 'outbox']:
            outboxMessages = json.loads(api.getAllSentMessages())
            numMessages = len(outboxMessages['sentMessages'])

            while True:
                msgNum = userInput(
                    'Enter the number of the message you wish to delete or (A)ll to empty the inbox.').lower()

                if msgNum in ['a', 'all']:
                    break
                elif int(msgNum) >= numMessages:
                    print('\n     Invalid Message Number.\n')
                else:
                    break

            uInput = userInput("Are you sure, (Y)es or (N)o?").lower()  # Prevent accidental deletion

            if uInput == "y":
                if msgNum in ['a', 'all']:
                    print(' ')
                    for msgNum in range(0, numMessages):  # processes all of the messages in the outbox
                        print('     Deleting message ', msgNum + 1, ' of ', numMessages)
                        delSentMsg(0)

                    print('\n     Outbox is empty.')
                    usrPrompt = 1
                else:
                    delSentMsg(int(msgNum))
                print('\n     Notice: Message numbers may have changed.\n')
                main()
            else:
                usrPrompt = 1
        else:
            print('\n     Invalid Entry.\n')
            usrPrompt = 1
            main()

    elif usrInput == "exit":
        print('\n     You are already at the main menu. Use "quit" to quit.\n')
        usrPrompt = 1
        main()

    elif usrInput == "listaddressbookentries":
        res = listAddressBookEntries()
        if res == 20:
            print('\n     Error: API function not supported.\n')
        usrPrompt = 1
        main()

    elif usrInput == "addaddressbookentry":
        address = userInput('Enter address')
        label = userInput('Enter label')
        res = addAddressToAddressBook(address, label)
        if res == 16:
            print('\n     Error: Address already exists in Address Book.\n')
        if res == 20:
            print('\n     Error: API function not supported.\n')
        usrPrompt = 1
        main()

    elif usrInput == "deleteaddressbookentry":
        address = userInput('Enter address')
        res = deleteAddressFromAddressBook(address)
        if res == 20:
            print('\n     Error: API function not supported.\n')
        usrPrompt = 1
        main()

    elif usrInput == "markallmessagesread":
        markAllMessagesRead()
        usrPrompt = 1
        main()

    elif usrInput == "markallmessagesunread":
        markAllMessagesUnread()
        usrPrompt = 1
        main()

    elif usrInput == "status":
        clientStatus()
        usrPrompt = 1
        main()

    elif usrInput == "shutdown":
        shutdown()
        usrPrompt = 1
        main()

    else:
        print('\n     "', usrInput, '" is not a command.\n')
        usrPrompt = 1
        main()


def main():
    """Entrypoint for the CLI app"""

    global api
    global usrPrompt

    if usrPrompt == 0:
        print('\n     ------------------------------')
        print('     | Bitmessage Daemon by .dok  |')
        print('     | Version 0.3.1 for BM 0.6.2 |')
        print('     ------------------------------')
        api = xmlrpclib.ServerProxy(apiData())  # Connect to BitMessage using these api credentials

        if apiTest() is False:
            print('\n     ****************************************************************')
            print('        WARNING: You are not connected to the Bitmessage client.')
            print('     Either Bitmessage is not running or your settings are incorrect.')
            print('     Use the command "apiTest" or "bmSettings" to resolve this issue.')
            print('     ****************************************************************\n')

        print('Type (H)elp for a list of commands.')  # Startup message
        usrPrompt = 2

    elif usrPrompt == 1:
        print('\nType (H)elp for a list of commands.')  # Startup message
        usrPrompt = 2

    try:
        UI((raw_input('>').lower()).replace(" ", ""))
    except EOFError:
        UI("quit")


if __name__ == "__main__":
    main()