#!/usr/bin/python

'''Command line Apport user interface.'''

# Copyright (C) 2007 - 2009 Canonical Ltd.
# Author: Michael Hofmann <mh21@piware.de>
# 
# This program 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 2 of the License, or (at your
# option) any later version.  See http://www.gnu.org/copyleft/gpl.html for
# the full text of the license.

# Web browser support:
#    w3m, lynx: do not work
#    elinks: works

import os.path, os, sys, subprocess, re, errno
import tty, termios, tempfile
from datetime import datetime

from apport import unicode_gettext as _
import apport.ui

class CLIDialog:
    '''Command line dialog wrapper.'''

    def __init__(self, heading, text):
        self.heading = '\n*** ' + heading + '\n'
        self.text = text
        self.keys = []
        self.buttons = []
        self.visible = False

    def raw_input_char(self, prompt):
        '''raw_input, but read only one character'''

        sys.stdout.write(prompt)
        sys.stdout.write(' ')

        file = sys.stdin.fileno()
        saved_attributes = termios.tcgetattr(file)
        attributes = termios.tcgetattr(file)
        attributes[3] = attributes[3] & ~(termios.ICANON)
        attributes[6][termios.VMIN] = 1
        attributes[6][termios.VTIME] = 0
        termios.tcsetattr(file, termios.TCSANOW, attributes)

        try:
            ch = str(sys.stdin.read(1))
        finally:
            termios.tcsetattr(file, termios.TCSANOW, saved_attributes)

        sys.stdout.write('\n')
        return ch

    def show(self):
        self.visible = True
        print(self.heading)
        if self.text:
            print(self.text)

    def run(self, prompt=None):
        if not self.visible:
            self.show()

        sys.stdout.write('\n')
        try:
            # Only one button
            if len (self.keys) <= 1:
                self.raw_input_char(_('Press any key to continue...'))
                return 0
            # Multiple choices
            while True:
                if prompt is not None:
                    print(prompt)
                else:
                    print(_('What would you like to do? Your options are:'))
                for index, button in enumerate(self.buttons):
                    print('  %s: %s' % (self.keys[index], button))

                response = self.raw_input_char(_('Please choose (%s):') % ('/'.join(self.keys)))
                try:
                    return self.keys.index(response[0].upper()) + 1
                except ValueError:
                    pass
        except KeyboardInterrupt:
            sys.stdout.write('\n')
            sys.exit(1)

    def addbutton(self, button, hotkey=None):
        if hotkey:
            self.keys.append(hotkey)
            self.buttons.append(button)
        else:
            self.keys.append(re.search('&(.)', button).group(1).upper())
            self.buttons.append(re.sub('&', '', button))
        return len(self.keys)


class CLIProgressDialog(CLIDialog):
    '''Command line progress dialog wrapper.'''

    def __init__(self, heading, text):
        CLIDialog.__init__(self, heading, text)
        self.progresscount = 0

    def set(self, progress = None):
        self.progresscount = (self.progresscount + 1) % 5
        if self.progresscount:
            return

        if progress != None:
            sys.stdout.write('\r%u%%' % (progress * 100))
        else:
            sys.stdout.write('.')
        sys.stdout.flush()

class CLIUserInterface(apport.ui.UserInterface):
    '''Command line Apport user interface'''

    def __init__(self):
        apport.ui.UserInterface.__init__(self)

    #
    # ui_* implementation of abstract UserInterface classes
    #

    def ui_present_crash(self, desktop_entry):
        date = datetime.strptime(self.report['Date'], '%a %b %d %H:%M:%S %Y')
        # adapt dialog heading and label appropriately
        if desktop_entry:
            name = desktop_entry.getName()
        elif 'ExecutablePath' in self.report:
            name = os.path.basename(self.report['ExecutablePath'])
        else:
            name = self.cur_package
        # translators: first %s: application name, second %s: date, third %s: time
        heading = _('%s closed unexpectedly on %s at %s.') % (name, date.date(), date.time())

        dialog = CLIDialog(
                heading,
                _('If you were not doing anything confidential (entering passwords or other\n'
                  'private information), you can help to improve the application by reporting\n'
                  'the problem.'))
        report = dialog.addbutton(_('&Report Problem...'))
        ignore = dialog.addbutton(_('Cancel and &ignore future crashes of this program version'))
        dialog.addbutton(_('&Cancel'))

        # show crash notification dialog
        response = dialog.run()

        if response == report:
            return {'action': 'report', 'blacklist': False}
        if response == ignore:
            return {'action': 'cancel', 'blacklist': True}
        # Fallback
        return {'action': 'cancel', 'blacklist': False}

    def ui_present_package_error(self):
        name = self.report['Package']
        dialog = CLIDialog(
                _('The package "%s" failed to install or upgrade.') % name,
                _('You can help the developers to fix the package by reporting the problem.'))
        report = dialog.addbutton(_('&Report Problem...'))
        dialog.addbutton(_('&Cancel'))

        response = dialog.run()

        if response == report:
            return 'report'
        # Fallback
        return 'cancel'

    def ui_present_kernel_error(self):
        message = _('Your system encountered a serious kernel problem.')
        annotation = ''
        if 'Annotation' in self.report:
            annotation += self.report['Annotation'] + '\n\n'
        annotation += _('You can help the developers to fix the problem by reporting it.')

        dialog = CLIDialog (message, annotation)
        report = dialog.addbutton(_('&Report Problem...'))
        dialog.addbutton(_('&Cancel'))

        response = dialog.run()

        if response == report:
            return 'report'
        # Fallback
        return 'cancel'

    def _get_details(self):
        '''Build report string for display.'''

        details = ''
        max_show = 1000000
        for key in sorted(self.report):
            details += key + ':'
            # string value
            keylen = len(self.report[key])
            if not hasattr(self.report[key], 'gzipvalue') and \
                hasattr(self.report[key], 'isspace') and \
                not self.report._is_binary(self.report[key]) and \
                keylen < max_show:
                lines = self.report[key].splitlines()
                if len(lines) <= 1:
                    details += ' ' + self.report[key] + '\n'
                else:
                    details += '\n'
                    for line in lines:
                        details += '  ' + line + '\n'
            elif keylen >= max_show:
                details += ' ' + (_('(%i bytes)') % keylen ) + '\n'
            else:
                details += ' ' + _('(binary data)') + '\n'

        return details


    def ui_present_report_details(self, is_update):
        if is_update:
            dialog = CLIDialog (_('Send this data to the developers?'), None)
        else:
            dialog = CLIDialog (_('Send problem report to the developers?'), 
                    _('After the problem report has been sent, please fill out the form in the\n'
                      'automatically opened web browser.'))

        # complete/reduced reports
        if 'CoreDump' in self.report and self.report.has_useful_stacktrace():
            complete = dialog.addbutton(_('&Send complete report (recommended; %s)') %
                    self.format_filesize(self.get_complete_size()))
            reduced = dialog.addbutton(_('Send &reduced report (slow Internet connection; %s)') %
                    self.format_filesize(self.get_reduced_size()))
        else:
            complete = dialog.addbutton(_('&Send report (%s)') %
                    self.format_filesize(self.get_complete_size()))
            reduced = None

        view = dialog.addbutton(_('&View report'))
        save = dialog.addbutton(_('&Keep report file for sending later or copying to somewhere else'))
        
        dialog.addbutton(_('&Cancel'))

        while True:
            response = dialog.run()

            if response == complete:
                return 'full'
            if response == reduced:
                return 'reduced'
            if response == view:
                try:
                    subprocess.Popen(["/usr/bin/sensible-pager"],
                            stdin=subprocess.PIPE,
                            close_fds=True).communicate(self._get_details())
                except IOError as e:
                    # ignore broken pipe (premature quit)
                    if e.errno == errno.EPIPE:
                        pass
                    else:
                        raise
                continue
            if response == save:
                # we do not already have a report file if we report a bug
                if not self.report_file:
                    prefix = 'apport.'
                    if 'Package' in self.report:
                        prefix += self.report['Package'].split()[0] + '.'
                    (fd, self.report_file) = tempfile.mkstemp(prefix=prefix, suffix='.apport')
                    self.report.write(os.fdopen(fd, 'w'))

                print(_('Problem report file:') + ' ' + self.report_file)
                return 'cancel'

            # Fallback
            return 'cancel'

    def ui_info_message(self, title, text):
        dialog = CLIDialog(title, text)
        dialog.addbutton(_('&Confirm'))
        dialog.run()

    def ui_error_message(self, title, text):
        dialog = CLIDialog(_('Error: %s') % title, text)
        dialog.addbutton(_('&Confirm'))
        dialog.run()

    def ui_start_info_collection_progress(self):
        self.progress = CLIProgressDialog (
                _('Collecting problem information'),
                _('The collected information can be sent to the developers to improve the\n'
                  'application. This might take a few minutes.'))
        self.progress.show()

    def ui_pulse_info_collection_progress(self):
        self.progress.set()

    def ui_stop_info_collection_progress(self):
        sys.stdout.write('\n')

    def ui_start_upload_progress(self):
        self.progress = CLIProgressDialog (
                _('Uploading problem information'),
                _('The collected information is being sent to the bug tracking system.\n'
                  'This might take a few minutes.'))
        self.progress.show()

    def ui_set_upload_progress(self, progress):
        self.progress.set(progress)

    def ui_stop_upload_progress(self):
        sys.stdout.write('\n')

    def ui_question_yesno(self, text):
        '''Show a yes/no question.

        Return True if the user selected "Yes", False if selected "No" or
        "None" on cancel/dialog closing.
        '''
        dialog = CLIDialog(text, None)
        r_yes = dialog.addbutton('&Yes')
        r_no = dialog.addbutton('&No')
        r_cancel = dialog.addbutton(_('&Cancel'))
        result = dialog.run()
        if result == r_yes:
            return True
        if result == r_no:
            return False
        assert result == r_cancel
        return None

    def ui_question_choice(self, text, options, multiple):
        '''Show an question with predefined choices.

        options is a list of strings to present. If multiple is True, they
        should be check boxes, if multiple is False they should be radio
        buttons.

        Return list of selected option indexes, or None if the user cancelled.
        If multiple == False, the list will always have one element.
        '''
        result = []
        dialog = CLIDialog(text, None)

        if multiple:
            while True:
                dialog = CLIDialog(text, None)
                index = 0
                choice_index_map = {}
                for option in options:
                    if index not in result:
                        choice_index_map[dialog.addbutton(option, str(index+1))] = index
                    index += 1
                done = dialog.addbutton(_('&Done'))
                cancel = dialog.addbutton(_('&Cancel'))

                if result:
                    cur = ', '.join([str(r+1) for r in result])
                else:
                    cur = _('none')
                response = dialog.run(_('Selected: %s. Multiple choices:') % cur)
                if response == cancel:
                    return None
                if response == done:
                    break
                result.append(choice_index_map[response])

        else:
            # single choice (radio button)
            dialog = CLIDialog(text, None)
            index = 1
            for option in options:
                dialog.addbutton(option, str(index))
                index += 1

            cancel = dialog.addbutton(_('&Cancel'))
            response = dialog.run(_('Choices:'))
            if response == cancel:
                return None
            result.append(response-1)

        return result

    def ui_question_file(self, text):
        '''Show a file selector dialog.

        Return path if the user selected a file, or None if cancelled.
        '''
        print('\n***  ' + text)
        while True:
            sys.stdout.write(_('Path to file (Enter to cancel):'))
            sys.stdout.write(' ')
            f = sys.stdin.readline().strip()
            if not f:
                return None
            if not os.path.exists(f):
                print(_('File does not exist.'))
            elif os.path.isdir(f):
                print(_('This is a directory.'))
            else:
                return f

    def open_url(self, url):
        text = '%s\n\n  %s\n\n%s' % (
            _('To continue, you must visit the following URL:'),
            url,
            _('You can launch a browser now, or copy this URL into a browser on another computer.'))

        answer = self.ui_question_choice(text, [_('Launch a browser now')], False)
        if answer == [0]:
            apport.ui.UserInterface.open_url(self, url)

if __name__ == '__main__':
    app = CLIUserInterface()
    if not app.run_argv():
        print(_('No pending crash reports. Try --help for more information.'))