#!/usr/bin/env python3

USERLENGTH = 50

# Important imports

import ipaddress, random, sys, etcd3, json, datetime, os
from flask import Flask, abort, request, Response, jsonify
from flask_restful import reqparse
from etcd3_wrapper import Etcd3Wrapper

# Generate random IPv6 address

def get_random_ip(network):
    net = ipaddress.IPv6Network(network)
    addr_offset = random.randrange(2**64)
    addr = net[0] + addr_offset
    return addr

# Check our own IPv6 address by using ipv6-test API
# This might be used to check internet connectivity
# def check_internet():
#    import urllib.request, urllib.error, urllib.parse
#    url = 'http://v6.ipv6-test.com/api/myip.php'
#    response = urllib.request.urlopen(url)
#    webContent = response.read()
#    return webContent

# RESTful flask arguments parsing

def require_args(*args):
    parser = reqparse.RequestParser()
    for arg in args:
        parser.add_argument(arg, required=True)
    return parser.parse_args()

# Classes

class Challenge(object):
    """ A sample challenge -- inherit this and overwrite accordingly """

    points = 0
    provides = []
    requires = []
    description = None
    dependencies_provided_by = {}

    def __init__(self, wrapper):
        self.db = wrapper

    def game(self):
        if request.method == 'GET':
            return self.describe()
        if request.method == 'POST':
            return self.solve()

    def describe(self):
        return self.description

    def save_points(self, user):
        """ should be called when the challenge was solved successfully"""

        key = "points/{}".format(user, type(self).__name__)
        #self.db.set_user_key(user, key, self.points)
        self.wrapper.put('/users' + user + '/points', self.points)

    def solve(self):
        """ Needs to be implemented per challenge """
        pass

# Challenge description works

class RegisterNet(Challenge):
    #self.etcbase = etcbase
    #self.wrapper = Etcd3Wrapper()
    #self.app = Flask(name)
    wrapper = Etcd3Wrapper()
    points = 10
    provides = [ "network" ]
    description = """
Register a /64 IPv6 network that you fully control.
Many other challenges depend on this. You will need to
be able to configure IPv6 addresses in this networks
and to setup services listening on these IPv6 addresses.

Submit your network with the "network" parameter.
"""
    def solve(self):
        #self.wrapper = Etcd3Wrapper()
        args = require_args("user", "network")
        network = args['network']
        user = args['user']

        try:
            net = ipaddress.IPv6Network(network)
        except Exception as e:
            return Response(status=400, response="Cannot register network {}: {}".format(network, e))

        if not net.prefixlen == 64:
            return Response(status=400, response="{} mask is not /64 - please use a /64 network".format(net))

        path = "{}/{}/points".format("/user", user)
        cur = self.wrapper.get(path)
        if cur == None:
            self.wrapper.put('/user/' + user + '/network', network)
            points = self.wrapper.get(path)
            self.wrapper.put('/user/' + user + '/points', '20') # Adjust points for first challenge here
            x = "Network {} registered, have fun with the next challenge!\n".format(network)
        else:
            x = "Network {} is already registered.\n".format(network)
        #self.db.set_user_key(user, "network", network)
        #save_points(user)
        return x

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

class IPv6Address(Challenge):
    wrapper = Etcd3Wrapper()
    points = 20
    requires = [ "network" ]
    description = """
You have setup your network, great!
Now it is time to show that you are really controlling your network!

Setup the IPv6 address

{}

and POST to this address, when it should be reachable by ping6.
"""

    def describe(self):
        args = require_args("user")
        user = args['user']
        #key = "network"

        network = self.wrapper.get('/user/' + user + '/network')
        if not network:
            return Response(status=400, response="""
Register a network before trying to be reachable. Possible challenges that
provide the network are:
{}
""".format("\n".join(self.dependencies_provided_by['network'])))


        #key = "address"
        address = self.wrapper.get('/user/' + user + '/ip')
        if not address:
            address = get_random_ip(network.value)
            #self.db.set_user_key(user, key, address)
        else:
            address = address.value

        return self.description.format(address)

    def solve(self):
        args = require_args("user")
        user = args['user']
        address = self.wrapper.get('/user/' + user + '/ip')
        response = os.system('ping -c 1 -t 3 ' + address.value)
        if response == 0:
          x = address.value + ' is up!'
        else:
          x = address.value + ' is down!'
        return x


class Game(object):
    def __init__(self, name, etcdclient, etcbase="/"):
        self.etcbase = etcbase
        self.wrapper = Etcd3Wrapper()
        self.app = Flask(name)
        #self.userbase = "{}/user".format(self.etcbase)

# Index text works! _

        def index():
            try:
                from_etcd = self.wrapper.get("/index")
                response = from_etcd.key, ' : ', from_etcd.value
            except:
                response = 'The key is empty.'
            return Response(response, 200)
        self.app.add_url_rule('/', 'index', index)

# End of index ^

# The registration works! _

        def register():
            args = require_args("user")
            user = args['user']
            value = str(datetime.datetime.now())
            netaddr = request.remote_addr
            cur = self.wrapper.get('/user/' + user)
            if cur == None:
                self.wrapper.put('/user/' + user, 'user exist')
                self.wrapper.put('/user/' + user + '/registered_at', value)
                self.wrapper.put('/user/' + user + '/ip', netaddr)
                x = "User @" + user + " successfully registered on " + value + " with IP: " + netaddr + '\n'
            else:
                time = self.wrapper.get('/user/' + user + '/registered_at')
                ip = self.wrapper.get('/user/' + user + '/ip')
                x = "User @" + user + " is already registered on " + time.value + ". His IP is: " + ip.value + '\n'
            return Response(x,200)
        self.app.add_url_rule('/register', 'register', register, methods=['POST'])

# End of registration ^

# Getting point for one user works! _

        def points():
            args = require_args("user")
            user = args['user']
            try:
                from_etcd = self.wrapper.get("/user/" + user + "/points")
                response = from_etcd.key, ' : ', from_etcd.value
            except:
                response = 'The key is empty.'
            return Response(response, 200)
        self.app.add_url_rule('/points', 'points', points, methods=['POST'])

# End of getting points ^

        # Automate this
        challenges = [ RegisterNet, IPv6Address ]
        challenge_instances = []

        self.providers = {}
        self.challenge_names = []
        for challenge in challenges:
            c = challenge(self.wrapper)
            challenge_instances.append(c)

            name = type(c).__name__
            self.challenge_names.append(name)
            path = "/challenge/{}".format(name)

            self.app.add_url_rule(path, name, c.game, methods=['GET', 'POST'])

            for provider in challenge.provides:
                if not provider in self.providers:
                    self.providers[provider] = []

                self.providers[provider].append(name)

        # Update challenges with provider information
        for challenge in challenge_instances:
            for requirement in challenge.requires:
                if not requirement in self.providers:
                    raise Exception("Unplayable server/game: {}".format(type(challenge).__name__))

                challenge.dependencies_provided_by[requirement] = self.providers[requirement]


# List of challenges works _

        def list_of_challenges():
            base = request.base_url
            challenges = [ "{} ({})".format(name, "{}/{}".format(base, name)) for name in self.challenge_names ]
            return """The following challenges are available on this server:
{}
""".format("\n".join(challenges))
        self.app.add_url_rule('/challenge', 'list_of_challenges', list_of_challenges)
        self.app.add_url_rule('/challenge/', 'list_of_challenges', list_of_challenges)   

# End of list of challenges ^

    def get_points(user):
        """ Returns a dict['username'] = points """

        #user_points = {}

        #path = "{}/".format(self.userbase)
        #users = self.wrapper.read_key_or_none(path)
        points = self.wrapper.get('/user/' + user + '/points').value

        ###if users:
         ###   for user in users:
        #        username = user.key.replace(path,"")
        #        user_points[username] = 0
           ###      print("inside users: user " + user)
                 #point_path = "{}/points".format(user.key)
           ###      points = self.wrapper.get("{}/points".format(user))
           ###      print("Points: " + points)
          #      if not points:
          #          continue

          #      for challenge in points.children:
          #          user_points[username] += int(challenge.value)

       # return user_points

   # def index(self):
       # points = self.points()

        return """Welcome to the game server!

Current point list is:

{}

For more information visit

https://code.ungleich.ch/nico/ungleich-game
""".format(points)

    def points(self):
        point_list = self.get_points()
        res = []
        if not point_list:
            return Response("No winners yet!")

        for k, v in point_list.items():
            res.append("{} has {} points".format(k, v))

        return """
Point list (aka high score)
---------------------------
{}
""".format("\n".join(res))

# This (below) works :D

if __name__ == '__main__':
    g = Game(__name__, etcd3.client(port=2379))
    g.app.run(host="::", port=5002)