#!/usr/bin/python
import os
import sys

import shutil
import parted
import subprocess
import optparse
import tempfile


def main():
    def usage():
        sys.exit(1)

    def cleanup():
        pass


    def mount(src, dst, options=None):
        if os.path.exists(src):
            if not os.path.exists(dst):
                os.makedir(dst)
            if options is None:
                args = ("/bin/mount", src, dst)
            else:
                args = ("/bin/mount", options, src, dst)
            rc = subprocess.call(args)
            return rc
        return


    def umount(src):
        if os.path.exists(src):
                args = ("/bin/umount", src)
                rc = subprocess.call(args)
                return rc
        return


    def copy(src, dst):
        if os.path.exists(src):
            shutil.copy(src, dst)


    def move(src, dst):
        if os.path.exists(src):
            shutil.mopve(src, dst)

    def mkdir(dir=None):
        if dir is None:
            tmp = tempfile.mkdtemp()
            return tmp
        else:
            args = ("/bin/mkdir", "-p", dir)
            rc = subprocess.call(args)


    def losetup(src, dst, offset=None):
        if os.path.exists(src):
            if os.path.exists(dst):
                if offset is None:
                    args = ("/sbin/losetup", src, dst)
                else:
                    args = ("/sbin/losetup", "-o", str(offset), src, dst)
                rc = subprocess.call(args)
        return rc

    def lounset(device):
        args = ("/sbin/losetup", "-d", device)
        rc = subprocess.call(args) 

    def null():
        fd = open(os.devnull, 'w')
        return fd

    def dd(file, target):
        args = ("/bin/dd", "if=%s"%file, "of=%s"%target)
        rc = subprocess.call(args)

    def lo():
        args = ("/sbin/losetup", "--find")
        rc = subprocess.Popen(args, stdout=subprocess.PIPE).communicate()[0].rstrip()
        return rc

    def lodev(multi):
        args = ("/sbin/losetup", "-j", multi)
        rc = subprocess.Popen(args, stdout=subprocess.PIPE).communicate()[0].split(":")
        return rc[0]


    def mkimage(bs, count):
        tmp = tempfile.mkstemp()
        image = tmp[1]
        args = ("/bin/dd", "if=/dev/zero",
                 "of=%s"%image, "bs=%s"%bs,
                 "count=%s"%count)
        rc = subprocess.call(args)
        return image


    def size(ent):
        if os.path.exists(ent):
            return os.stat(ent).st_size

    def bs(size):
        return size / 2048

    def partition(device, sectors):
        dev = parted.Device(path=device)
        disk = parted.freshDisk(dev, 'msdos')

        start = 1
        end = sectors
 
        new_geom = parted.Geometry(device=dev,
                                   start=start,
                                   end=end)
        partition = parted.Partition(disk=disk,
                                     type=82,
                                     geometry=new_geom)
        constraint = parted.Constraint(exactGeom=new_geom)
        disk.addPartition(partition=partition,
                          constraint=constraint)
        disk.commit()

    def format(partition):
        args = ("/sbin/mke2fs", "-j", partition)
        rc = subprocess.call(args)

    def mbr(target):
        mbr = "/usr/share/syslinux/mbr.bin"
        dd(mbr, target)
        


    def setup(x86, x64, multi):

        sz = size(x86) + size(x64)
        count = bs(sz)
        blsz = str(2048)

        multi = mkimage(blsz, count)    
        losetup(lo(), multi)
 
        sectors = size(multi) / 512 - 1
        partition(lodev(multi), sectors)
        mbr(lodev(multi))
 
        lounset(lodev(multi))
     
        losetup(lo(), multi, offset=512)
        format(lodev(multi))

        multitmp = mkdir()
        mount(lodev(multi), multitmp)

        losetup(lo(), x86)
        losetup(lo(), x64)
 
        x86tmp = mkdir()
        x64tmp = mkdir()

        mount(lodev(x86), x86tmp)
        mount(lodev(x64), x64tmp)


        dirs = ("/syslinux/", "/x86/", "/x64/")
        for dir in dirs:
            mkdir(multitmp + dir)
        dirs = "/LiveOS/"
        for dir in x86, x64:
            mkdir(multitmp + dir + dirs)

        
 
        




    def parse(x86, x64, multi):
        for file in x86, x64:
            if os.path.exists(file):
                pass
            else:
                usage()
        if not multi:
            usage()
        setup(x86, x64, multi)





    #try: 
    parse(sys.argv[1], sys.argv[2], sys.argv[3])
    #except:
    #    usage()



        
        


if __name__ == "__main__":
    sys.exit(main())