def get_disk_mount(disk_id):
    TEMP_DIR = 'C:\\temp\\kano-burner\\'
    disk_mount = ''   # mount point e.g. C:\ or D:\

    # extract the id of the physical disk, required by diskpart
    # e.g. \\?\Device\Harddisk[id]\Partition0
    id = int(disk_id.split("Harddisk")[1][0])  # access by string index alone is dangerous!

    # create a diskpart script to find the mount point for the given disk
    diskpart_detail_script = 'select disk {} \ndetail disk'.format(id)
    write_file_contents(TEMP_DIR + "detail_disk.txt", diskpart_detail_script)

    # run the created diskpart script
    cmd = 'diskpart /s {}'.format(TEMP_DIR + "detail_disk.txt")
    output, error, return_code = run_cmd_no_pipe(cmd)

    if not return_code:
        debugger('Ran diskpart detail script')
    else:
        debugger('[ERROR] ' + error.strip('\n'))
        return

    # now the mount point is the third word on the last line of the output
    disk_mount = output.splitlines()[-1].split()[2]

    return disk_mount

def test_write(disk_mount):
    cmd = '{}\\dd.exe if=/dev/random of=\\\\.\\{}: bs=4M count=10'.format(_dd_path, disk_mount)
    _, output, return_code = run_cmd_no_pipe(cmd)

    if not return_code:
        debugger('Written 40M random data to {}:\\'.format(disk_mount))
    else:
        debugger('[ERROR]: ' + output.strip('\n'))

def format_disk(disk_id):
    cmd = 'mkdosfs -I -F 32 -v {}'.format(disk_id)
    _, error, return_code = run_cmd(cmd)

    if not return_code:
        debugger('{} successfully erased and formatted'.format(disk_id))
    else:
        debugger('[ERROR] ' + error.strip('\n'))

def close_all_explorer_windows():
    cmd = '{}\\nircmd.exe win close class "CabinetWClass"'.format(_nircmd_path)
    _, error, return_code = run_cmd_no_pipe(cmd)

    if not return_code:
        debugger('Closed all Explorer windows')
    else:
        debugger('[ERROR]: ' + error.strip('\n'))

def unmount_disk(disk_id):
    cmd = 'diskutil unmountDisk {}'.format(disk_id)
    _, error, return_code = run_cmd(cmd)

    if not return_code:
        debugger('{} successfully unmounted'.format(disk_id))
    else:
        debugger('[ERROR] ' + error.strip('\n'))

def unzip_kano_os(os_path, dest_path):
    cmd = '"{}\\7za.exe" e "{}" -o"{}"'.format(_7zip_path, os_path, dest_path)
    _, output, return_code = run_cmd_no_pipe(cmd)

    if not return_code:
        debugger('Unzipped Kano OS successfully')
    else:
        debugger('[ERROR]: ' + output.strip('\n'))

def get_disk_ids():
    cmd = "diskutil list | grep '/dev/'"
    output, error, return_code = run_cmd(cmd)

    if not return_code:
        return output.split()
    else:
        debugger('[ERROR] ' + error.strip('\n'))

def is_installed(programs_list):
    cmd = 'which {}'.format(' '.join(programs_list))
    output, error, return_code = run_cmd(cmd)

    if return_code:
        debugger('[ERROR] ' + error.strip('\n'))
        return True  # if something goes wrong here, it shouldn't be catastrophic

    return len(output.split()) == len(programs_list)

def unmount_disk(disk_id):
    cmd = 'diskutil unmountDisk {}'.format(disk_id)
    _, error, return_code = run_cmd(cmd)

    if not return_code:
        debugger('{} successfully unmounted'.format(disk_id))
    else:
        debugger('[ERROR: {}] {}'.format(cmd,  error.strip('\n')))
        raise disk_error(UNMOUNT_ERROR)

 def getAriaStatus(self):
     self.process.poll()
     if not self.process.returncode:
         try:
             self.ariaStatus = self.server.aria2.tellStatus('token:'+self.secret, self.gid)
             if not isinstance(self.ariaStatus, dict):
                 self.ariaStatus = {}
         except Exception as e:
             self.failed = True
             self.failure = e
             debugger('status call error {}'.format(e))

def is_sufficient_space(path, required_mb):
    cmd = "df %s | grep -v 'Available' | awk '{print $4}'" % path
    output, _, _ = run_cmd(cmd)

    try:
        free_space_mb = float(output.strip()) * 512 / BYTES_IN_MEGABYTE
    except:
        debugger('[ERROR] Failed parsing the line ' + output)
        return True

    debugger('Free space {0:.2f} MB in {1}'.format(free_space_mb, path))
    return free_space_mb > required_mb

def mount_disk(disk_id):
    # the following may not work if the disk has been unmounted, consider caching
    disk_mount = get_disk_mount(disk_id)
    disk_volume = get_disk_volume(disk_id, disk_mount)

    cmd = "mountvol {}:\\ {}".format(disk_mount, disk_volume)
    _, error, return_code = run_cmd_no_pipe(cmd)

    if not return_code:
        debugger('{} successfully mounted'.format(disk_mount))
    else:
        debugger('[ERROR]: ' + error.strip('\n'))

    def isFinished(self):
        self.process.poll()
        if self.process.returncode:
            debugger('aria returned {}'.format(self.status.returncode))
            return True  # aria finished; since it's not supposed to until we tell it, it probably died
        if self.failed:
            debugger('aria failed {}'.format(self.failure))
            return True

        self.getAriaStatus()
        result = self.ariaStatus['status']
        finished = result != 'active' and result != 'waiting'
        return finished

def get_disk_sizes():
    cmd = "fdisk -l | grep 'Disk /dev/'"
    output, error, return_code = run_cmd(cmd)

    disk_sizes = []
    for line in sorted(output.splitlines()):
        size = line.split()[4]
        disk_sizes.append(float(size) / BYTES_IN_GIGABYTE)

    if return_code:
        debugger('[ERROR] ' + error.strip('\n'))

    return disk_sizes

def eject_disk(disk_id):
    '''
    This method is used by the backendThread to ensure safe removal
    after burning finished successfully.
    '''

    cmd = 'diskutil eject {}'.format(disk_id)
    _, error, return_code = run_cmd(cmd)

    if not return_code:
        debugger('{} successfully ejected'.format(disk_id))
    else:
        debugger('[ERROR] ' + error.strip('\n'))

def get_disk_names():
    cmd = "parted --list | grep 'Model:'"
    output, error, return_code = run_cmd(cmd)

    disk_names = []
    for name in output.splitlines():
        disk_names.append(' '.join(name.split()[1:-1]))

    if return_code:
        debugger('[ERROR] ' + error.strip('\n'))

    # grab the first line of the output and the name is from the 4th word onwards
    return disk_names

def poll_burning_thread(thread):
    time.sleep(1)  # wait for dd to start
    debugger('Polling burner for progress..')
    cmd = 'kill -INFO `pgrep ^dd`'

    # as long as the burning thread is running, send SIGINFO
    # to dd to trigger progress output
    while thread.is_alive():
        _, error, return_code = run_cmd(cmd)
        if return_code:
            debugger('[ERROR] Sending signal to burning thread failed')
            return False
        time.sleep(0.3)
    return True

def is_installed(programs_list):
    cmd = 'where.exe {}'.format(' '.join(programs_list))
    output, error, return_code = run_cmd_no_pipe(cmd)

    if return_code:
        debugger('[ERROR] ' + error.strip('\n'))
        return True  # if something goes wrong here, it shouldn't be catastrophic

    programs_found = 0
    for line in output.splitlines():
        if line and 'not find' not in line:
            programs_found += 1

    return programs_found == len(programs_list)

def unmount_volumes(disk_id):
    # all volumes on a disk have an index attached e.g. /dev/sdb1, /dev/sdb2
    cmd = "fdisk -l | grep '%s[0-9][0-9]*' | awk '{print $1}'" % disk_id
    output, _, _ = run_cmd(cmd)

    # it may also happen that the disk does not have volumes
    # in which case the loop below won't do anything
    for volume in output.splitlines():
        cmd = 'umount {}'.format(volume)
        _, error, return_code = run_cmd(cmd)
        if not return_code:
            debugger('volume {} successfully unmounted'.format(volume))
        else:
            debugger('[ERROR] ' + error.strip('\n'))

def is_sufficient_space(required_mb):
    cmd = "dir {}".format(temp_path)
    output, _, _ = run_cmd_no_pipe(cmd)

    try:
        # grab the last line from the output
        free_space_line = output.splitlines()[-1]

        # grab the number in bytes, remove comma delimiters, and convert to MB
        free_space_mb = float(free_space_line.split()[2].replace(',', '')) / BYTES_IN_MEGABYTE
    except:
        debugger('[ERROR] Failed parsing the line ' + output)
        return True

    debugger('Free space {0:.2f} MB in {1}'.format(free_space_mb, temp_path))
    return free_space_mb > required_mb