#!/usr/bin/env python

# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.

import json
import random
import uuid

from oslo_config import cfg
from oslo_log import log
from prettytable import PrettyTable
import requests

from faafo import version


LOG = log.getLogger('faafo.client')
CONF = cfg.CONF


def get_random_task():
    random.seed()

    if CONF.command.width:
        width = int(CONF.command.width)
    else:
        width = random.randint(int(CONF.command.min_width),
                               int(CONF.command.max_width))

    if CONF.command.height:
        height = int(CONF.command.height)
    else:
        height = random.randint(int(CONF.command.min_height),
                                int(CONF.command.max_height))

    if CONF.command.iterations:
        iterations = int(CONF.command.iterations)
    else:
        iterations = random.randint(int(CONF.command.min_iterations),
                                    int(CONF.command.max_iterations))

    if CONF.command.xa:
        xa = float(CONF.command.xa)
    else:
        xa = random.uniform(float(CONF.command.min_xa),
                            float(CONF.command.max_xa))

    if CONF.command.xb:
        xb = float(CONF.command.xb)
    else:
        xb = random.uniform(float(CONF.command.min_xb),
                            float(CONF.command.max_xb))

    if CONF.command.ya:
        ya = float(CONF.command.ya)
    else:
        ya = random.uniform(float(CONF.command.min_ya),
                            float(CONF.command.max_ya))

    if CONF.command.yb:
        yb = float(CONF.command.yb)
    else:
        yb = random.uniform(float(CONF.command.min_yb),
                            float(CONF.command.max_yb))

    task = {
        'data': {
            'type': 'fractal',
            'attributes': {
                'uuid': str(uuid.uuid4()),
                'width': width,
                'height': height,
                'iterations': iterations,
                'xa': xa,
                'xb': xb,
                'ya': ya,
                'yb': yb
            }
        }
    }

    return task


def do_get_fractal():
    LOG.error("command 'download' not yet implemented")


def do_show_fractal():
    LOG.info("showing fractal %s" % CONF.command.uuid)
    headers = {'Content-Type': 'application/vnd.api+json',
                'Accept': 'application/vnd.api+json'}
    result = requests.get("%s/v1/fractal/%s" %
                          (CONF.endpoint_url, CONF.command.uuid),
                          headers=headers)
    LOG.debug("result: %s" % result.text)

    if result.status_code == 200:
        data = json.loads(result.text)
        fractal_data = data['data']['attributes']
        output = PrettyTable(["Parameter", "Value"])
        output.align["Parameter"] = "l"
        output.align["Value"] = "l"
        output.add_row(["uuid", fractal_data['uuid']])
        output.add_row(["duration", "%f seconds" % fractal_data['duration']])
        output.add_row(["dimensions", "%d x %d pixels" %
                                      (fractal_data['width'], fractal_data['height'])])
        output.add_row(["iterations", fractal_data['iterations']])
        output.add_row(["xa", fractal_data['xa']])
        output.add_row(["xb", fractal_data['xb']])
        output.add_row(["ya", fractal_data['ya']])
        output.add_row(["yb", fractal_data['yb']])
        output.add_row(["size", "%d bytes" % fractal_data['size']])
        output.add_row(["checksum", fractal_data['checksum']])
        output.add_row(["generated_by", fractal_data['generated_by']])
        print(output)
    else:
        LOG.error("fractal '%s' not found" % CONF.command.uuid)


def do_list_fractals():
    LOG.info("listing all fractals")

    fractals = get_fractals()
    output = PrettyTable(["UUID", "Dimensions", "Filesize"])
    for fractal in fractals:
        fractal_data = fractal['attributes']
        output.add_row([
            fractal_data["uuid"],
            "%d x %d pixels" % (fractal_data["width"], fractal_data["height"]),
            "%d bytes" % (fractal_data["size"] or 0),
        ])
    print(output)


def get_fractals(page=1):
    headers = {'Content-Type': 'application/vnd.api+json',
                'Accept': 'application/vnd.api+json'}
    result = requests.get("%s/v1/fractal?page=%d&page[size]=10" %
                          (CONF.endpoint_url, page),
                          headers=headers)
    LOG.debug("result: %s" % result.text)


    fractals = []
    if result.status_code == 200:
        data = json.loads(result.text)
        if (page * 10) < data['meta']['total']:
            fractals = data['data'] + get_fractals(page + 1)
        else:
            return data['data']

    return fractals


def do_delete_fractal():
    LOG.info("deleting fractal %s" % CONF.command.uuid)
    headers = {'Content-Type': 'application/vnd.api+json',
                'Accept': 'application/vnd.api+json'}
    result = requests.delete("%s/v1/fractal/%s" %
                             (CONF.endpoint_url, CONF.command.uuid),
                             headers=headers)
    LOG.debug("result: %s" % result.text)

def do_delete_all():
    LOG.info("deleting everything")
    fractals = get_fractals()
    for f in fractals:
        fractal_data = f["attributes"]
        uuid = fractal_data["uuid"]

        CONF.command.uuid = uuid
        do_delete_fractal()
def do_delete_slected_fractal():
    LOG.info("deleting given fractals %s" % CONF.command.uuid)
    raw_list= CONF.command.uuid.split(",")
    for uuid in raw_list:
        headers = {'Content-Type': 'application/vnd.api+json',
                'Accept': 'application/vnd.api+json'}
        result = requests.delete("%s/v1/fractal/%s" %
                             (CONF.endpoint_url, uuid),
                             headers=headers)
        LOG.debug("result: %s" % result.text)

def do_create_fractal():
    random.seed()
    if CONF.command.tasks:
        number = int(CONF.command.tasks)
    else:
        number = random.randint(int(CONF.command.min_tasks),
                                int(CONF.command.max_tasks))
    LOG.info("generating %d task(s)" % number)
    for i in range(0, number):
        task = get_random_task()
        LOG.debug("created task %s" % task)
        headers = {'Content-Type': 'application/vnd.api+json',
                   'Accept': 'application/vnd.api+json'}
        resp = requests.post("%s/v1/fractal" % CONF.endpoint_url,
                      json.dumps(task), headers=headers)
        LOG.debug("resp: %s" % resp.text)


def add_command_parsers(subparsers):
    parser = subparsers.add_parser('create')
    parser.set_defaults(func=do_create_fractal)
    parser.add_argument("--height", default=None,
                        help="The height of the generate image.")
    parser.add_argument("--min-height", default=256,
                        help="The minimum height of the generate image.")
    parser.add_argument("--max-height", default=1024,
                        help="The maximum height of the generate image.")
    parser.add_argument("--width", default=None,
                        help="The width of the generated image.")
    parser.add_argument("--min-width", default=256,
                        help="The minimum width of the generated image.")
    parser.add_argument("--max-width", default=1024,
                        help="The maximum width of the generated image.")
    parser.add_argument("--iterations", default=None,
                        help="The number of iterations.")
    parser.add_argument("--min-iterations", default=128,
                        help="The minimum number of iterations.")
    parser.add_argument("--max-iterations", default=512,
                        help="The maximum number of iterations.")
    parser.add_argument("--tasks", default=None,
                        help="The number of generated fractals.")
    parser.add_argument("--min-tasks", default=1,
                        help="The minimum number of generated fractals.")
    parser.add_argument("--max-tasks", default=10,
                        help="The maximum number of generated fractals.")
    parser.add_argument("--xa", default=None,
                        help="The value for the parameter 'xa'.")
    parser.add_argument("--min-xa", default=-1.0,
                        help="The minimum value for the parameter 'xa'.")
    parser.add_argument("--max-xa", default=-4.0,
                        help="The maximum value for the parameter 'xa'.")
    parser.add_argument("--xb", default=None,
                        help="The value for the parameter 'xb'.")
    parser.add_argument("--min-xb", default=1.0,
                        help="The minimum value for the parameter 'xb'.")
    parser.add_argument("--max-xb", default=4.0,
                        help="The maximum value for the parameter 'xb'.")
    parser.add_argument("--ya", default=None,
                        help="The value for the parameter 'ya'.")
    parser.add_argument("--min-ya", default=-0.5,
                        help="The minimum value for the parameter 'ya'.")
    parser.add_argument("--max-ya", default=-3,
                        help="The maximum value for the parameter 'ya'.")
    parser.add_argument("--yb", default=None,
                        help="The value for the parameter 'yb'.")
    parser.add_argument("--min-yb", default=0.5,
                        help="The minimum value for the parameter 'yb'.")
    parser.add_argument("--max-yb", default=3,
                        help="The maximum value for the parameter 'yb'.")

    parser = subparsers.add_parser('delete')
    parser.set_defaults(func=do_delete_fractal)
    parser.add_argument("uuid", help="Fractal to delete.")
    
    ## no arguments
    parser = subparsers.add_parser('delete-all')
    parser.set_defaults(func=do_delete_all)
    
 ## it takes a list of uuids separated by commas
    parser = subparsers.add_parser('delete-selected')
    parser.set_defaults(func=do_delete_slected_fractal)
    parser.add_argument("uuid", help="deleting the selected fractals. enter the uuid separated by commas.")

    parser = subparsers.add_parser('show')
    parser.set_defaults(func=do_show_fractal)
    parser.add_argument("uuid", help="Fractal to show.")

    parser = subparsers.add_parser('get')
    parser.set_defaults(func=do_get_fractal)
    parser.add_argument("uuid", help="Fractal to download.")

    parser = subparsers.add_parser('list')
    parser.set_defaults(func=do_list_fractals)


client_commands = cfg.SubCommandOpt('command', title='Commands',
                                    help='Show available commands.',
                                    handler=add_command_parsers)

CONF.register_cli_opts([client_commands])

client_cli_opts = [
    cfg.StrOpt('endpoint-url',
               default='http://localhost',
               help='API connection URL')
]

CONF.register_cli_opts(client_cli_opts)


if __name__ == '__main__':
    log.register_options(CONF)
    log.set_defaults()

    CONF(project='client', prog='faafo-client',
         version=version.version_info.version_string())

    log.setup(CONF, 'client',
              version=version.version_info.version_string())

    CONF.command.func()
