#!/usr/bin/env python

import os
import re
import yaml
import argparse

try:
    import pyrax
    HAS_PYRAX = True
except ImportError:
    HAS_PYRAX = False


def rax_list_iterator(svc, *args, **kwargs):
    method = kwargs.pop('method', 'list')
    items = getattr(svc, method)(*args, **kwargs)
    while items:
        retrieved = getattr(svc, method)(*args, marker=items[-1].id, **kwargs)
        if items and retrieved and items[-1].id == retrieved[0].id:
            del items[-1]
        items.extend(retrieved)
        if len(retrieved) < 2:
            break
    return items


def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument('-y', '--yes', action='store_true', dest='assumeyes',
                        default=False, help="Don't prompt for confirmation")
    parser.add_argument('--match', dest='match_re',
                        default='^ansible-testing',
                        help='Regular expression used to find resources '
                             '(default: %(default)s)')

    return parser.parse_args()


def authenticate():
    try:
        with open(os.path.realpath('./credentials.yml')) as f:
            credentials = yaml.load(f)
    except Exception as e:
        raise SystemExit(e)

    try:
        pyrax.set_credentials(credentials.get('rackspace_username'),
                              credentials.get('rackspace_api_key'))
    except Exception as e:
        raise SystemExit(e)


def prompt_and_delete(item, prompt, assumeyes):
    if not assumeyes:
        assumeyes = raw_input(prompt).lower() == 'y'
    assert hasattr(item, 'delete') or hasattr(item, 'terminate'), \
            "Class <%s> has no delete or terminate attribute" % item.__class__
    if assumeyes:
        if hasattr(item, 'delete'):
            item.delete()
            print ("Deleted %s" % item)
        if hasattr(item, 'terminate'):
            item.terminate()
            print ("Terminated %s" % item)


def delete_rax(args):
    """Function for deleting CloudServers"""
    print ("--- Cleaning CloudServers matching '%s'" % args.match_re)
    search_opts = dict(name='^%s' % args.match_re)
    for region in pyrax.identity.services.compute.regions:
        cs = pyrax.connect_to_cloudservers(region=region)
        servers = rax_list_iterator(cs.servers, search_opts=search_opts)
        for server in servers:
            prompt_and_delete(server,
                              'Delete matching %s? [y/n]: ' % server,
                              args.assumeyes)


def delete_rax_clb(args):
    """Function for deleting Cloud Load Balancers"""
    print ("--- Cleaning Cloud Load Balancers matching '%s'" % args.match_re)
    for region in pyrax.identity.services.load_balancer.regions:
        clb = pyrax.connect_to_cloud_loadbalancers(region=region)
        for lb in rax_list_iterator(clb):
            if re.search(args.match_re, lb.name):
                prompt_and_delete(lb,
                                  'Delete matching %s? [y/n]: ' % lb,
                                  args.assumeyes)


def delete_rax_keypair(args):
    """Function for deleting Rackspace Key pairs"""
    print ("--- Cleaning Key Pairs matching '%s'" % args.match_re)
    for region in pyrax.identity.services.compute.regions:
        cs = pyrax.connect_to_cloudservers(region=region)
        for keypair in cs.keypairs.list():
            if re.search(args.match_re, keypair.name):
                prompt_and_delete(keypair,
                                  'Delete matching %s? [y/n]: ' % keypair,
                                  args.assumeyes)


def delete_rax_network(args):
    """Function for deleting Cloud Networks"""
    print ("--- Cleaning Cloud Networks matching '%s'" % args.match_re)
    for region in pyrax.identity.services.network.regions:
        cnw = pyrax.connect_to_cloud_networks(region=region)
        for network in cnw.list():
            if re.search(args.match_re, network.name):
                prompt_and_delete(network,
                                  'Delete matching %s? [y/n]: ' % network,
                                  args.assumeyes)


def delete_rax_cbs(args):
    """Function for deleting Cloud Networks"""
    print ("--- Cleaning Cloud Block Storage matching '%s'" % args.match_re)
    for region in pyrax.identity.services.network.regions:
        cbs = pyrax.connect_to_cloud_blockstorage(region=region)
        for volume in cbs.list():
            if re.search(args.match_re, volume.name):
                prompt_and_delete(volume,
                                  'Delete matching %s? [y/n]: ' % volume,
                                  args.assumeyes)


def delete_rax_cdb(args):
    """Function for deleting Cloud Databases"""
    print ("--- Cleaning Cloud Databases matching '%s'" % args.match_re)
    for region in pyrax.identity.services.database.regions:
        cdb = pyrax.connect_to_cloud_databases(region=region)
        for db in rax_list_iterator(cdb):
            if re.search(args.match_re, db.name):
                prompt_and_delete(db,
                                  'Delete matching %s? [y/n]: ' % db,
                                  args.assumeyes)


def _force_delete_rax_scaling_group(manager):
    def wrapped(uri):
        manager.api.method_delete('%s?force=true' % uri)
    return wrapped


def delete_rax_scaling_group(args):
    """Function for deleting Autoscale Groups"""
    print ("--- Cleaning Autoscale Groups matching '%s'" % args.match_re)
    for region in pyrax.identity.services.autoscale.regions:
        asg = pyrax.connect_to_autoscale(region=region)
        for group in rax_list_iterator(asg):
            if re.search(args.match_re, group.name):
                group.manager._delete = \
                    _force_delete_rax_scaling_group(group.manager)
                prompt_and_delete(group,
                                  'Delete matching %s? [y/n]: ' % group,
                                  args.assumeyes)


def main():
    if not HAS_PYRAX:
        raise SystemExit('The pyrax python module is required for this script')

    args = parse_args()
    authenticate()

    funcs = [f for n, f in globals().items() if n.startswith('delete_rax')]
    for func in sorted(funcs, key=lambda f: f.__name__):
        try:
            func(args)
        except Exception as e:
            print ("---- %s failed (%s)" % (func.__name__, e.message))


if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        print ('\nExiting...')
