#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# 2016 Darko Poljak (darko.poljak at ungleich.ch)
#
# This file is part of cdist.
#
# cdist is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# cdist is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with cdist. If not, see <http://www.gnu.org/licenses/>.
#
#

import cdist
import cdist.config
import cdist.core
import cdist.preos
import argparse
import cdist.argparse
import logging
import os
import subprocess


class Debian(object):
    _preos_name = 'debian'
    _cdist_preos = True

    _files_dir = os.path.join(os.path.dirname(__file__), "files")

    @classmethod
    def default_args(cls):
        default_remote_exec = os.path.join(cls._files_dir, "remote-exec.sh")
        default_remote_copy = os.path.join(cls._files_dir, "remote-copy.sh")
        default_init_manifest = os.path.join(
            cls._files_dir, "init-manifest-{}".format(cls._preos_name))

        defargs = argparse.Namespace()
        defargs.arch = 'amd64'
        defargs.bootstrap = False
        defargs.configure = False
        defargs.cdist_params = '-v'
        defargs.rm_bootstrap_dir = False
        defargs.suite = 'stable'
        defargs.remote_exec = default_remote_exec
        defargs.remote_copy = default_remote_copy
        defargs.manifest = default_init_manifest

        return defargs

    @classmethod
    def get_parser(cls):
        defargs = cls.default_args()
        cdist_parser = cdist.argparse.get_parsers()
        parser = argparse.ArgumentParser(
                prog='cdist preos {}'.format(cls._preos_name),
                parents=[cdist_parser['loglevel'], cdist_parser['beta']])
        parser.add_argument('target_dir', nargs=1,
                            help=("target directory where PreOS will be "
                                  "bootstrapped"))
        parser.add_argument(
            '-a', '--arch',
            help="target debootstrap architecture, by default '{}'".format(
                defargs.arch), dest='arch', default=defargs.arch)
        parser.add_argument(
            '-B', '--bootstrap',
            help='do bootstrap step',
            dest='bootstrap', action='store_true', default=defargs.bootstrap)
        parser.add_argument(
            '-C', '--configure',
            help='do configure step',
            dest='configure', action='store_true', default=defargs.configure)
        parser.add_argument(
            '-c', '--cdist-params',
            help=("parameters that will be passed to cdist config, by default"
                  " '{}' is used".format(defargs.cdist_params)),
            dest='cdist_params', default=defargs.cdist_params)
        parser.add_argument(
            '-D', '--drive-boot',
            help='create bootable PreOS on specified drive',
            dest='drive')
        parser.add_argument(
            '-e', '--remote-exec',
            help=("remote exec that cdist config will use, by default "
                  "internal script is used"),
            dest='remote_exec', default=defargs.remote_exec)
        parser.add_argument(
            '-i', '--init-manifest',
            help=("init manifest that cdist config will use, by default "
                  "internal init manifest is used"),
            dest='manifest', default=defargs.manifest)
        parser.add_argument(
            '-k', '--keyfile', action="append",
            help=("ssh key files that will be added to cdist config; "
                  "'__ssh_authorized_keys root ...' type is appended to "
                  "initial manifest"),
            dest='keyfile')
        parser.add_argument(
            '-m', '--mirror',
            help='use specified mirror for debootstrap',
            dest='mirror')
        parser.add_argument(
            '-P', '--root-password',
            help='Set specified password for root, generated by default',
            dest='root_password')
        parser.add_argument('-p', '--pxe-boot-dir', help='PXE boot directory',
                            dest='pxe_boot_dir')
        parser.add_argument(
            '-r', '--rm-bootstrap-dir',
            help='remove target directory after finishing',
            dest='rm_bootstrap_dir', action='store_true',
            default=defargs.rm_bootstrap_dir)
        parser.add_argument(
            '-S', '--script',
            help='use specified script for debootstrap',
            dest='script')
        parser.add_argument('-s', '--suite',
                            help="suite used for debootstrap, "
                                 "by default '{}'".format(defargs.suite),
                            dest='suite', default=defargs.suite)
        parser.add_argument(
            '-y', '--remote-copy',
            help=("remote copy that cdist config will use, by default "
                  "internal script is used"),
            dest='remote_copy', default=defargs.remote_copy)
        parser.epilog = cdist.argparse.EPILOG

        return parser

    @classmethod
    def update_env(cls, env):
        pass

    @classmethod
    def commandline(cls, argv):
        log = logging.getLogger(cls.__name__)

        parser = cls.get_parser()
        cdist.argparse.add_beta_command(cls._preos_name)
        args = parser.parse_args(argv)
        if args.script and not args.mirror:
            raise cdist.Error("script option cannot be used without "
                              "mirror option")

        args.command = cls._preos_name
        cdist.argparse.check_beta(vars(args))

        cdist.preos.check_root()

        args.target_dir = os.path.realpath(args.target_dir[0])
        args.os = cls._preos_name
        args.remote_exec = os.path.realpath(args.remote_exec)
        args.remote_copy = os.path.realpath(args.remote_copy)
        args.manifest = os.path.realpath(args.manifest)
        if args.keyfile:
            new_keyfile = [os.path.realpath(x) for x in args.keyfile]
            args.keyfile = new_keyfile
        if args.pxe_boot_dir:
            args.pxe_boot_dir = os.path.realpath(args.pxe_boot_dir)

        cdist.argparse.handle_loglevel(args)
        log.debug("preos: {}, args: {}".format(cls._preos_name, args))
        try:
            env = vars(args)
            new_env = {}
            for key in env:
                if key == 'verbose':
                    if env[key] >= 3:
                        new_env['debug'] = "yes"
                    elif env[key] == 2:
                        new_env['verbose'] = "yes"
                elif not env[key]:
                    new_env[key] = ''
                elif isinstance(env[key], bool) and env[key]:
                    new_env[key] = "yes"
                elif isinstance(env[key], list):
                    val = env[key]
                    new_env[key + "_cnt"] = str(len(val))
                    for i, v in enumerate(val):
                        new_env[key + "_" + str(i)] = v
                else:
                    new_env[key] = str(env[key])
            env = new_env
            env.update(os.environ)
            cls.update_env(env)
            log.debug("preos: {} env: {}".format(cls._preos_name, env))
            cmd = os.path.join(cls._files_dir, "code")
            info_msg = ["Running preos: {}, suite: {}, arch: {}".format(
                cls._preos_name, args.suite, args.arch), ]
            if args.mirror:
                info_msg.append("mirror: {}".format(args.mirror))
            if args.script:
                info_msg.append("script: {}".format(args.script))
            if args.bootstrap:
                info_msg.append("bootstrapping")
            if args.configure:
                info_msg.append("configuring")
            if args.pxe_boot_dir:
                info_msg.append("creating PXE")
            if args.drive:
                info_msg.append("creating bootable drive")
            log.info(info_msg)
            log.debug("cmd={}".format(cmd))
            subprocess.check_call(cmd, env=env, shell=True)
        except subprocess.CalledProcessError as e:
            log.error("preos {} failed: {}".format(cls._preos_name, e))


class Ubuntu(Debian):
    _preos_name = "ubuntu"

    @classmethod
    def default_args(cls):
        defargs = super().default_args()
        defargs.suite = 'xenial'
        return defargs


class Devuan(Debian):
    _preos_name = "devuan"

    @classmethod
    def default_args(cls):
        defargs = super().default_args()
        defargs.suite = 'jessie'
        return defargs

    @classmethod
    def update_env(cls, env):
        env['DEBOOTSTRAP_DIR'] = os.path.join(cls._files_dir,
                                              'devuan-debootstrap')