#!/usr/bin/env python3

import configparser
import os
import shlex
import subprocess
import sys

LOCALBASE="/usr/local"

default_conf="""
[default]
disk_path=%s/zfsfs
jails=83i386,83amd64,91i386,91amd64
disable_jails=83amd64
debug=True

[83i386]
name=83i386
arch=i386
version=8.3-RELEASE

[83amd64]
name=83dm64
arch=amd64
version=8.3-RELEASE

[91i386]
name=91i386
arch=i386
version=9.1-RELEASE

[91amd64]
name=91amd64
arch=amd64
version=9.1-RELEASE
""" % LOCALBASE

class Prunner(object):
    def __init__(self):
        self._jails = load_jails()
        self._port_trees = []
        self.setup()

    def setup(self, **params):
        if debug:
            print("setup...")
        #TODO: create jail using method ftp + test if exists
        params['host'] = 'FREEBSD_HOST=ftp.fr.freebsd.org'
        for jail in self._jails:
            cmd = "poudriere jail -c -j {0} -a {1} -v {2} {3}".format(
                jail['name'],
                jail['arch'],
                jail['version'],
                params['host'])
            if debug:
                print("exec: {0}".format(cmd))
            sudo(cmd)

    def teardown(self):
        #TODO: kill jail (stop them)
        for jail in self._jails:
            cmd = "poudriere jail -k -j {0}".format(jail['name'])
            if debug:
                print("exec: {0}".format(cmd))
            sudo(cmd)

    @property
    def jails(self):
       return self._jails

    @property
    def port_trees(self):
       return self._port_trees

    def test_port(self, origin, port_tree="ptree"):
        for jail in self._jails:
            if debug:
                print("testport o: {0}: j: {1}".format(origin, jail['name']))
            cmd = "poudriere testport -o {0} -j {1} -p {2}".format(
                    origin,
                    jail['name'], port_tree)
            out, err = sudo(cmd)
            if debug:
                print("j: {0}, out: {1}, err: {2}".format(jail['name'], out, err))

    def test_all(self):
        for o in self.sbzports():
            self.test_port(o)

    def bulk(self, jail):
        pass

    def sbzports(self):
        # I have a file in my home ~/sbzports
        ports = open('{0}/sbzports'.format(os.path.expanduser('~%s' % os.environ['USER'])), 'r').read().strip().split('\n')
        return ports

    def __del__(self):
        if debug:
            print("teardown()...")
        self.teardown()

def run(command, use_sudo=False):
    command = "sudo %s" % command if use_sudo else command
    p = subprocess.Popen(shlex.split(command), stdout=subprocess.PIPE)
    stdout, stderr = p.communicate()
    p.wait()
    return stdout.strip(), stderr

def sudo(command):
    return run(command, use_sudo=True)

def load_disk():
    disk_path = cfg.get('default', 'disk_path')
    if not os.path.exists('/dev/md0'):
        out, err = sudo("mdconfig -t vnode -a -f {0}".format(disk_path))

def load_jails():
    jails = []
    existing_jails = cfg.get('default', 'jails').split(',')
    existing_jails.remove(cfg.get('default', 'disable_jails'))

    for jail in existing_jails:
        print(jail)
        name = cfg.get(jail, 'name')
        arch = cfg.get(jail, 'arch')
        version = cfg.get(jail, 'version')
        jails.append({'name': name, 'arch': arch, 'version': version})

    return jails

def testport(origin):
    for j in load_jails():
        out, err = sudo("poudriere testport -o {0} -j {1} -p ptree".format(origin, j['name']))
        if debug:
            print("j: {0}, out: {1}, err: {2}".format(j['name'], out, err))

def main():
    global cfg, debug
    cfg = configparser.ConfigParser()
    cfg.read_string(default_conf)
    debug = cfg.get('default', 'debug')
    print(cfg.get('default', 'disk_path'))

    load_disk()
    print(load_jails())

    runner = Prunner()
    runner.test_port('security/libssh2')

    #runner.test_all()

if __name__ == '__main__':
    main()