#!/usr/bin/env python3

# Sarah's custom tests for Part 2.

import random
import traceback
import inspect
import math
from servers import StorageServer, PublicKeyServer
from crypto import Crypto
from base_client import IntegrityError

#########################
#  FUNCTIONALITY TESTS  #
#########################

globs = dict(globals())

def t01_collidingnames(C, pks, crypto, server):
    """bummer"""
    alice = C("alice")
    bob = C("bob")
    carol = C("carol")

    alice.upload("filename", "value")
    carol.upload("c", "value2")

    m = alice.share("bob", "filename")
    bob.receive_share("alice", "fileb", m)

    m = carol.share("bob", "c")
    bob.receive_share("carol", "fileb", m)
    score = bob.download("fileb") == "value2"

    m = alice.share("bob", "filename")
    bob.receive_share("alice", "fileb", m)
    score += bob.download("fileb") == "value"

    alice.revoke("bob", "filename")
    carol.upload("c", "value3")
    alice.upload("filename", "aaa")

    try:
        score += bob.download("fileb") != "aaa"
    except IntegrityError:
        score += 1
    score += carol.download("c") == "value3"
    score += alice.download("filename") == "aaa"
    try:
        score += bob.download("fileb") != "value3"
    except IntegrityError:
        score += 1

    return score/6.0


def t2_revokestillaccess(C, pks, crypto, server):
    """ yeah man"""
    alice = C("alice")
    bob = C("bob")
    carol = C("carol")
    dave = C("dave")

    alice.upload("f", "a")

    m = alice.share("bob", "f")
    bob.receive_share("alice", "fb", m)

    m = alice.share("carol", "f")
    carol.receive_share("alice", "fc", m)

    m = carol.share("dave", "fc")
    dave.receive_share("carol", "fd1", m)

    m = bob.share("dave", "fb")
    dave.receive_share("bob", "fd2", m)


    alice.revoke("bob", "f")
    score = dave.download("fd1") == "a"
    try:
        score += dave.download("fd2") != "a"
    except IntegrityError:
        score += 1

    return score/2.0

def t3_revokeusercannotupdate(C, pks, crypto, server):
    """last one!"""
    alice = C("alice")
    bob = C("bob")
    carol = C("carol")
    dave = C("dave")

    alice.upload("f", "a")

    m = alice.share("bob", "f")
    bob.receive_share("alice", "fb", m)

    m = alice.share("carol", "f")
    carol.receive_share("alice", "fc", m)

    m = carol.share("dave", "fc")
    dave.receive_share("carol", "fd1", m)

    alice.revoke("carol", "f")
    try:
        dave.upload("fd1", "b")
    except IntegrityError:
        score = 1
    try:
        carol.upload("fc", "c")
    except IntegrityError:
        score += 1
    return score/2.0

def t4_manyUsers(C, pks, crypto, server):
    names = list(range(100))
    names = [str(name) for name in names]
    clients = [C(name) for name in names]
    filenames = ["file" + user for user in names]
    content = "£€†←♠🐧🚴🎸®" * 763
    # content = "it's Sunday today!"
    score = 0

    clients[0].upload(filenames[0], content)
    for i in range(len(names) - 1):
        sharer = clients[i]
        sharee = clients[i+1]
        m = sharer.share(names[i + 1], filenames[i])
        assert isinstance(m, str)
        sharee.receive_share(names[i], filenames[i + 1], m)

    for i in range(len(names)):
        score += clients[i].download(filenames[i]) == content

    return score / 100

def t5_invalid_input_into_upload(C, pks, crypto, server):
    """makes sure that invalid value input exits gracefully"""
    alice = C("alice")
    score = 0
    try:
        alice.upload("a", 124)
    except IntegrityError:
        score += 1
    try:
        alice.upload(alice, alice)
    except IntegrityError:
        score += 1
    return score / 2
def t6_share_before_file_uploaded(C, pks, crypto, server):
    """ensure that if share() is called before the user has uploaded anything to the server => integrity error"""
    alice = C("alice")
    bob = C("bob")
    score = 0
    try:
        alice.share("bob", "k")
    except IntegrityError:
        score += 1
    try:
        alice.share("carol", "k")
    except IntegrityError:
        score += 1
    return score / 2

def t7_recv_share_before_file_uploaded(C, pks, crypto, server):
    """ensure that if recv_share() is called before the user has uploaded anything to the server => integrity error"""
    alice = C("alice")
    bob = C("bob")
    score = 0
    try:
        alice.receive_share("bob", "aj", "")
    except IntegrityError:
        score += 1
    try:
        alice.receive_share("carol", "llw", "")
    except IntegrityError:
        score += 1
    return score / 2


def t8_revoke_before_file_uploaded(C, pks, crypto, server):
    """ensure that if revoke() is called before the user has uploaded anything to the server => integrity error"""
    alice = C("alice")
    bob = C("bob")
    score = 0
    try:
        alice.revoke("bob", "k")
    except IntegrityError:
        score += 1
    try:
        alice.revoke("carol", "k")
    except IntegrityError:
        score += 1
    return score / 5

gs = dict(globals())

functionality_tests = []
for g, f in sorted(gs.items()):
    if (g not in globs and g != "globs" and "__" not in g and
            type(f) == type(lambda x: x)):
        functionality_tests.append((g, f))


class StudentTester:
    def __init__(self, theclass):
        self.theclass = theclass

    def run_test(self, t, Server=StorageServer, Crypto=Crypto,
                 Pks=PublicKeyServer):
        argspec = inspect.getargspec(t)
        if argspec.defaults is None:
            types = {}
        else:
            types = dict(zip(argspec.args[-len(argspec.defaults):],
                             argspec.defaults))

        server = types['server']() if 'server' in types else Server()
        pks = types['pks']() if 'pks' in types else Pks()
        crypto = types['crypto']() if 'crypto' in types else Crypto()
        myclient = __import__(self.theclass, fromlist=[''])

        def C(name):
            return myclient.Client(server, pks, crypto, name)
        return t(C, pks, crypto, server)


def run_custom_tests():
    """Runs all part 2 functionality tests."""

    """
    score = StudentTester("client").run_test(t4_manyUsers)
    if score >= .99999:
        print("\tTest Passes")
    else:
        print("\tTest FAILED.")

    score = StudentTester("client").run_test(t5_invalid_input_into_upload)
    if score >= .99999:
        print("\tTest Passes")
    else:
        print("\tTest FAILED.")
    """
    for testname, test in functionality_tests:
        print("============")
        print("Running test", testname)
        try:
            score = StudentTester("client").run_test(test)
            if score >= .99999:
                print("\tTest Passes")
            else:
                print("\tTest FAILED.")
                print("\t"+test.__doc__)
        except:
            print("\tTest FAILED.")
            print("\t"+test.__doc__)
            traceback.print_exc()
            print("\n\n")

if __name__ == "__main__":
    run_custom_tests()