#!/usr/bin/env python

#    Copyright 2011 OpenStack Foundation
#
#    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.

"""
Reddwarf Command line tool
"""

import json
import optparse
import os
import sys


# If ../trove/__init__.py exists, add ../ to Python search path, so that
# it will override what happens to be installed in /usr/(local/)lib/python...
possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
                                   os.pardir,
                                   os.pardir))
if os.path.exists(os.path.join(possible_topdir, 'troveclient',
                               '__init__.py')):
    sys.path.insert(0, possible_topdir)
if os.path.exists(os.path.join(possible_topdir, 'nova', '__init__.py')):
    sys.path.insert(0, possible_topdir)


from troveclient import common


oparser = None


def _pretty_print(info):
    print json.dumps(info, sort_keys=True, indent=4)


class InstanceCommands(object):
    """Commands to perform various instances operations and actions"""

    def __init__(self):
        pass

    def create(self, name, volume_size,
               flavorRef="http://localhost:8775/v1.0/flavors/1"):
        """Create a new instance"""
        dbaas = common.get_client()
        volume = {"size": volume_size}
        try:
            result = dbaas.instances.create(name, flavorRef, volume)
            _pretty_print(result._info)
        except:
            print sys.exc_info()[1]

    def delete(self, id):
        """Delete the specified instance"""
        dbaas = common.get_client()
        try:
            result = dbaas.instances.delete(id)
            if result:
                print result
        except:
            print sys.exc_info()[1]

    def get(self, id):
        """Get details for the specified instance"""
        dbaas = common.get_client()
        try:
            _pretty_print(dbaas.instances.get(id)._info)
        except:
            print sys.exc_info()[1]

    def list(self):
        """List all instances for account"""
        dbaas = common.get_client()
        try:
            for instance in dbaas.instances.list():
                _pretty_print(instance._info)
        except:
            print sys.exc_info()[1]

    def resize(self, id, size):
        """Resize an instance volume"""
        dbaas = common.get_client()
        try:
            result = dbaas.instances.resize(id, size)
            if result:
                print result
        except:
            print sys.exc_info()[1]

    def restart(self, id):
        """Restart the database"""
        dbaas = common.get_client()
        try:
            result = dbaas.instances.restart(id)
            if result:
                print result
        except:
            print sys.exc_info()[1]


class FlavorsCommands(object):
    """Commands for listing Flavors"""

    def __init__(self):
        pass

    def list(self):
        """List the available flavors"""
        dbaas = common.get_client()
        try:
            for flavor in dbaas.flavors.list():
                _pretty_print(flavor._info)
        except:
            print sys.exc_info()[1]


class DatabaseCommands(object):
    """Database CRUD operations on an instance"""

    def __init__(self):
        pass

    def create(self, id, dbname):
        """Create a database"""
        dbaas = common.get_client()
        try:
            databases = [{'name': dbname}]
            dbaas.databases.create(id, databases)
        except:
            print sys.exc_info()[1]

    def delete(self, id, dbname):
        """Delete a database"""
        dbaas = common.get_client()
        try:
            dbaas.databases.delete(id, dbname)
        except:
            print sys.exc_info()[1]

    def list(self, id):
        """List the databases"""
        dbaas = common.get_client()
        try:
            for database in dbaas.databases.list(id):
                _pretty_print(database._info)
        except:
            print sys.exc_info()[1]


class UserCommands(object):
    """User CRUD operations on an instance"""

    def __init__(self):
        pass

    def create(self, id, username, password, dbname, *args):
        """Create a user in instance, with access to one or more databases"""
        dbaas = common.get_client()
        try:
            databases = [{'name': dbname}]
            [databases.append({"name": db}) for db in args]
            users = [{'name': username, 'password': password,
                      'databases': databases}]
            dbaas.users.create(id, users)
        except:
            print sys.exc_info()[1]

    def delete(self, id, user):
        """Delete the specified user"""
        dbaas = common.get_client()
        try:
            dbaas.users.delete(id, user)
        except:
            print sys.exc_info()[1]

    def list(self, id):
        """List all the users for an instance"""
        dbaas = common.get_client()
        try:
            for user in dbaas.users.list(id):
                _pretty_print(user._info)
        except:
            print sys.exc_info()[1]


class RootCommands(object):
    """Root user related operations on an instance"""

    def __init__(self):
        pass

    def create(self, id):
        """Enable the instance's root user."""
        dbaas = common.get_client()
        try:
            user, password = dbaas.root.create(id)
            print "User:\t\t%s\nPassword:\t%s" % (user, password)
        except:
            print sys.exc_info()[1]

    def enabled(self, id):
        """Check the instance for root access"""
        dbaas = common.get_client()
        try:
            _pretty_print(dbaas.root.is_root_enabled(id))
        except:
            print sys.exc_info()[1]


class VersionCommands(object):
    """List available versions"""

    def __init__(self):
        pass

    def list(self, url):
        """List all the supported versions"""
        dbaas = common.get_client()
        try:
            versions = dbaas.versions.index(url)
            for version in versions:
                _pretty_print(version._info)
        except:
            print sys.exc_info()[1]


def config_options():
    global oparser
    oparser.add_option("-u", "--url", default="http://localhost:5000/v1.1",
                       help="Auth API endpoint URL with port and version. \
                            Default: http://localhost:5000/v1.1")


COMMANDS = {'auth': common.Auth,
            'instance': InstanceCommands,
            'flavor': FlavorsCommands,
            'database': DatabaseCommands,
            'user': UserCommands,
            'root': RootCommands,
            'version': VersionCommands}


def main():
    # Parse arguments
    global oparser
    oparser = optparse.OptionParser("%prog [options] <cmd> <action> <args>",
                                    version='1.0')
    config_options()
    (options, args) = oparser.parse_args()

    if not args:
        common.print_commands(COMMANDS)

    # Pop the command and check if it's in the known commands
    cmd = args.pop(0)
    if cmd in COMMANDS:
        fn = COMMANDS.get(cmd)
        command_object = fn()

        # Get a list of supported actions for the command
        actions = common.methods_of(command_object)

        if len(args) < 1:
            common.print_actions(cmd, actions)

        # Check for a valid action and perform that action
        action = args.pop(0)
        if action in actions:
            fn = actions.get(action)

            try:
                fn(*args)
                sys.exit(0)
            except TypeError as err:
                print "Possible wrong number of arguments supplied."
                print "%s %s: %s" % (cmd, action, fn.__doc__)
                print "\t\t", [fn.func_code.co_varnames[i] for i in
                                            range(fn.func_code.co_argcount)]
                print "ERROR: %s" % err
            except Exception:
                print "Command failed, please check the log for more info."
                raise
        else:
            common.print_actions(cmd, actions)
    else:
        common.print_commands(COMMANDS)


if __name__ == '__main__':
    main()