#!/usr/bin/python3
# -*- coding: utf-8 -*-

import argparse
import os
from pkg_resources import parse_version

from spoc import repo_local
from spoc import repo_online
from spoc import repo_publish
from spoc.app import App
from spoc.cli import readable_size

def listing(list_type):
    if list_type == 'installed':
        apps = repo_local.get_apps()
    elif list_type == 'online':
        apps = repo_online.get_apps()
    elif list_type == 'updates':
        online_apps = repo_online.get_apps()
        apps = [a for a,d in repo_local.get_apps() if a in online_apps and parse_version(online_apps[a]['version']) > parse_version(d['version'])]
    elif list_type == 'published':
        apps = repo_publish.get_apps()
    for app in apps:
        print(app)

def install():
    raise NotImplementedException()

def upgrade():
    raise NotImplementedException()

def uninstall():
    raise NotImplementedException()

def start():
    raise NotImplementedException()

def stop():
    raise NotImplementedException()

def status():
    raise NotImplementedException()

def publish(filename, force):
    app_name = os.path.basename(os.path.dirname(os.path.abspath(filename)))
    # Check if publishing is needed and attempt to publish the application
    if force or app_name not in repo_publish.get_apps():
        app = App(app_name, False)
        print(f'Publishing application {app_name} from file {os.path.abspath(filename)}')
        app.unpublish()
        size, dlsize = app.publish(filename)
        print(f'Application {app_name} compressed from {readable_size(size)} to {readable_size(dlsize)} and published successfully')
    else:
        print(f'Application {app_name} already published, skipping publish task')

def unpublish(app_name):
    App(app_name, False).unpublish()

parser = argparse.ArgumentParser(description='SPOC application manager')
parser.set_defaults(action=None)
subparsers = parser.add_subparsers()

parser_list = subparsers.add_parser('list')
parser_list.set_defaults(action=listing)
parser_list.add_argument('type', choices=('installed', 'online', 'updates', 'published'), default='installed', const='installed', nargs='?')

parser_install = subparsers.add_parser('install')
parser_install.set_defaults(action=install)
parser_install.add_argument('app')

parser_upgrade = subparsers.add_parser('upgrade')
parser_upgrade.set_defaults(action=upgrade)
parser_upgrade.add_argument('app')

parser_uninstall = subparsers.add_parser('uninstall')
parser_uninstall.set_defaults(action=uninstall)
parser_uninstall.add_argument('app')

parser_start = subparsers.add_parser('start')
parser_start.set_defaults(action=start)
parser_start.add_argument('app')

parser_stop = subparsers.add_parser('stop')
parser_stop.set_defaults(action=stop)
parser_stop.add_argument('app')

parser_status = subparsers.add_parser('status')
parser_status.set_defaults(action=status)
parser_status.add_argument('app')

parser_publish = subparsers.add_parser('publish')
parser_publish.set_defaults(action=publish)
parser_publish.add_argument('-f', '--force', action='store_true', help='Force republish already published application')
parser_publish.add_argument('filename')

parser_unpublish = subparsers.add_parser('unpublish')
parser_unpublish.set_defaults(action=unpublish)
parser_unpublish.add_argument('app')

args = parser.parse_args()

if args.action is listing:
    listing(args.type)
elif args.action is install:
    install(args.app)
elif args.action is upgrade:
    upgrade(args.app)
elif args.action is uninstall:
    uninstall(args.app)
elif args.action is start:
    start(args.app)
elif args.action is stop:
    stop(args.app)
elif args.action is status:
    status(args.app)
elif args.action is publish:
    publish(args.filename, args.force)
elif args.action is unpublish:
    unpublish(args.app)
else:
    parser.print_usage()