bchoc

#!/usr/bin/env python3

from os import getenv
import argparse
from typing import *
from datetime import datetime, timezone
from uuid import UUID
from blockchain import Blockchain

def doAdd(args: argparse.Namespace):
    bchain = Blockchain()

    for id in args.itemIDs:
        if bchain.get_block(id) != None:
            print("Error: Evidence ID {} not unique.".format(id))
            exit(-1)

    caseID = UUID(args.caseID)
    print("Case: {}".format(caseID))
    for id in args.itemIDs:
        bchain.write_block(caseID, id, "CHECKEDIN", "")

        print("Added item: {}".format(id))
        print("  Status: CHECKEDIN")
        print("  Time of action: {}".format(datetime.now()))

def doCheckout(args: argparse.Namespace):
    bchain = Blockchain()

    id = args.itemID
    block = bchain.get_block(id)
    if block is not None:
        state = block['state']
    else:
        print("Error: Evidence item {} does not exist. Please add it.".format(id))
        exit(-1)

    if state == "INITIAL":
        print("Error: Evidence item {} is not a valid item.".format(id))
        exit(-1)
    elif state == "CHECKEDOUT":
        print("Error: Evidence item {} is already checked out. Must check it in first.".format(id))
        exit(-1)
    elif state == "DISPOSED":
        print("Error: Evidence item {} has been disposed. Cannot check it out.".format(id))
        exit(-1)
    elif state == "DESTROYED":
        print("Error: Evidence item {} has been destroyed. Cannot check it out.".format(id))
        exit(-1)
    elif state == "RELEASED":
        print("Error: Evidence item {} has been released. Cannot check it out.".format(id))
        exit(-1)

    # Checkout item
    case = block['case_id']
    bchain.write_block(case, id, "CHECKEDOUT", "")

    print("Case: {}".format(case))
    print("Checked out item: {}".format(id))
    print("  Status: CHECKEDOUT")
    print("  Time of action: {}".format(datetime.now()))


def doCheckin(args: argparse.Namespace):
    bchain = Blockchain()

    id = args.itemID
    block = bchain.get_block(id)
    if block is not None:
        state = block['state']
    else:
        print("Error: Evidence item {} does not exist. Please add it.".format(id))
        exit(-1)

    if state == "INITIAL":
        print("Error: Evidence item {} is not a valid item.".format(id))
        exit(-1)
    elif state == "CHECKEDIN":
        print("Error: Evidence item {} is already checked in. Must check it out first.".format(id))
        exit(-1)
    elif state == "DISPOSED":
        print("Error: Evidence item {} is disposed. Cannot check it in.".format(id))
        exit(-1)
    elif state == "DESTROYED":
        print("Error: Evidence item {} is destroyed. Cannot check it in.".format(id))
        exit(-1)
    elif state == "RELEASED":
        print("Error: Evidence item {} is released. Cannot check it in.".format(id))
        exit(-1)

    # Check in item
    case = block['case_id']
    bchain.write_block(case, id, "CHECKEDIN", "")
    
    print("Case: {}".format(case))
    print("Checked in item: {}".format(id))
    print("  Status: CHECKEDIN")
    print("  Time of action: {}".format(datetime.now()))

def print_blocks(blocks):
    for block in blocks:
        if block["state"] == "INITIAL":
            print("Case: 00000000-0000-0000-0000-000000000000")
            print("Item: 0")
        else:
            print(f"Case: {block['case_id']}")
            print(f"Item: {block['item_id']}")
        print(f"Action: {block['state']}")
        print(f"Time: {block['timestamp'].isoformat()}")
        print()


def doLog(args: argparse.Namespace):
    bchain = Blockchain()

    is_reversed = args.reversed
    n = args.numEntries
    case_id = args.caseID
    item_id = args.itemID

    blocks = bchain.read_blocks()
    if is_reversed: blocks = reversed(blocks)
    if case_id is not None:
        blocks = filter(lambda block: str(block["case_id"]) == case_id, blocks)
    if item_id is not None:
        blocks = filter(lambda block: block["item_id"] == item_id, blocks)
    print_blocks(blocks if n is None else blocks[:n])


def doRemove(args: argparse.Namespace):
    bchain = Blockchain()

    id = args.itemID
    block = bchain.get_block(id)
    if block is not None:
        state = block['state']
    else:
        print("Error: Evidence item {} does not exist. Please add it.".format(id))
        exit(-1)
    
    if state != "CHECKEDIN":
        print("Error: Evidence item {} must be checked in to remove it. Please check it in.".format(id))
        exit(-1)

    reason = args.reason
    owner = args.owner # What happens if this is not given? None?
    if reason == "RELEASED" and owner == None:
        print("Error: Must give a reason in order to release.")
        exit(-1)
    elif reason == "DISPOSED" and owner != None:
        print("Error: Disposed evidence does not need an owner.")
        exit(-1)
    elif reason == "DESTROYED" and owner != None:
        print("Error: Destroyed evidence does not need an owner.")
        exit(-1)
    elif reason != "RELEASED" and reason != "DISPOSED" and reason != "DESTROYED":
        print("Error: Not a valid reason to remove an item.")
        exit(-1)

    # Remove evidence
    case = block['case_id']
    if reason == "RELEASED":
        bchain.write_block(case, id, "RELEASED", owner + "\x00")

        print("Case: {}".format(case))
        print("Released item: {}".format(id))
        print("  Status: RELEASED")
        print("  Time of action: {}".format(datetime.now()))
    elif reason == "DISPOSED":
        bchain.write_block(case, id, "DISPOSED", "")

        print("Case: {}".format(case))
        print("Disposed of item: {}".format(id))
        print("  Status: DISPOSED")
        print("  Time of action: {}".format(datetime.now()))
    elif reason == "DESTROYED":
        bchain.write_block(case, id, "DESTROYED", "")

        print("Case: {}".format(case))
        print("Destroyed item: {}".format(id))
        print("  Status: DESTROYED")
        print("  Time of action: {}".format(datetime.now()))


def doInit(args: argparse.Namespace):
    bchain = Blockchain()

    if bchain.check_init():
        print("Verified the initial block.")
    else:
        print("The blockchain file provided is invalid.")
        exit(-1)

def doVerify(args: argparse.Namespace):
    doInit(args)
    bchain = Blockchain()

    if bchain.verify_valid():
        print("Verified validity of blocks.")
    else:
        print("One or more blocks are invalid.")
        exit(-1)
    if bchain.verify_duplicate_parents():
        print("Verified linear structure.")
    else:
        print("Multiple blocks have the same parent.")
        exit(-1)
    if bchain.verify_checksums():
        print("Verified checksums.")
    else:
        print("The blockchain contains a block with incorrect checksum.")
        exit(-1)
    if bchain.verify_status_good():
        print("Verified status values.")
    else:
        print("Invalid status value in one of the blocks.")
        exit(-1)
    if bchain.verify_releases_are_good():
        print("Verified the integrity of release blocks.")
    else:
        print("A release operation done improperly.")
        exit(-1)
    if bchain.verify_add_is_first():
        print("Verified the correct use of add method.")
    else:
        print("Operations ran on items before their addition.")
        exit(-1)
    if bchain.verify_remove_is_final():
        print("Verified the correct use of remove method.")
    else:
        print("Operations ran on items after their removal.")
        exit(-1)
    if bchain.verify_check_order():
        print("Verified the correct order of checkins and checkouts.")
    else:
        print("An item checked or checked out while in an improper state.")
        exit(-1)
    print("BLOCKCHAIN VERIFICATION FINISHED")

def loadChainFromFile(filePath):
    pass


def main() -> None:
    modes: List[str] = ["add", "checkout", "checkin", "log", "remove", "init", "verify"]

    argumentParser: argparse.ArgumentParser = argparse.ArgumentParser()
    subparsers = argumentParser.add_subparsers(dest="mode")

    modeParsers: Dict[str, Any] = {
        mode: subparsers.add_parser(mode) for mode in modes
    }

    modeParsers["add"].add_argument("-c", "--case_id", dest="caseID", type=str, required=True)
    modeParsers["add"].add_argument("-i", "--item_id", dest="itemIDs", type=int, required=True, action="append")

    modeParsers["checkout"].add_argument("-i", "--item_id", dest="itemID", type=int, required=True)

    modeParsers["checkin"].add_argument("-i", "--item_id", dest="itemID", type=int, required=True)

    modeParsers["log"].add_argument("-r", "--reverse", dest="reversed", action="store_true")
    modeParsers["log"].add_argument("-n", "--num_entries", dest="numEntries", type=int)
    modeParsers["log"].add_argument("-c", "--case_id", dest="caseID", type=str)
    modeParsers["log"].add_argument("-i", "--item_id", dest="itemID", type=int)
    
    modeParsers["remove"].add_argument("-i", "--item_id", dest="itemID", type=int, required=True)
    modeParsers["remove"].add_argument("-y", "--why", dest="reason", type=str, required=True)
    modeParsers["remove"].add_argument("-o", "--owner", dest="owner", type=str)

    args: argparse.Namespace = argumentParser.parse_args()

    modeFunctionName: str = f"do{args.mode.capitalize()}"
    globalVals: Dict[str, Any] = globals()
    if (modeFunctionName not in globalVals):
        print(f'Function "{modeFunctionName}" not implemented')
        exit(-1)
    
    globalVals[modeFunctionName](args)


if __name__ == '__main__':
    main()