#!/usr/bin/python

import apt
import locale
import datetime
import os
import subprocess
import gettext

from apt.utils import *
from aptsources.sourceslist import SourcesList
from gettext import gettext as _
from optparse import OptionParser
from UpdateManager.Core.utils import twrap

CODENAME = subprocess.Popen(["lsb_release","-c","-s"],
                            stdout=subprocess.PIPE).communicate()[0].strip()

# gettext sugar
def N_(message): return message


def get_maintenance_status(cache, pkgname, supported_tag):
    if supported_tag.endswith("y"):
        supported_for_n_month = 12*int(supported_tag.rstrip("y"))
    elif supported_tag.endswith("m"):
        supported_for_n_month = int(supported_tag.rstrip("m"))
    else:
        raise Exception("Unsupported tag '%s'" % supported_tag)

    # try to figure out the support dates of the release and make
    # sure to look only for stuff in "Ubuntu" and "distro_codename"
    # (to exclude stuff in ubuntu-updates for the support time 
    # calculation because the "Release" file time for that gets
    # updated regularly)
    releasef = get_release_filename_for_pkg(cache, pkgname, 
                                            "Ubuntu", CODENAME)
    if not releasef:
        releasef = get_release_filename_for_pkg(cache, pkgname, 
                                            "Ubuntu", CODENAME + "-updates")

    time_t = get_release_date_from_release_file(releasef)
    # check the release date and show support information
    # based on this
    if not time_t:
        raise Exception("No date tag found")
    release_date = datetime.datetime.fromtimestamp(time_t)
    now = datetime.datetime.now()
    
    # mvo: we do not define the end date very precisely
    #      currently this is why it will just display a end
    #      range
    (support_end_year, support_end_month) = get_maintenance_end_date(release_date, supported_for_n_month)
    support_end_month_str = locale.nl_langinfo(getattr(locale,"MON_%d" % support_end_month))
    # check if the support has ended
    support_ended = (now.year > support_end_year or
                     (now.year == support_end_year and now.month > support_end_month))

    # build dict for the argument string
    d = { 'support_tag' : supported_tag,
          'support_end_month_str' : support_end_month_str,
          'support_end_year' : support_end_year }

    if support_ended:
        return (False, "%(support_end_month_str)s %(support_end_year)s (%(support_tag)s)" % d)
    return (True, "%(support_end_month_str)s %(support_end_year)s (%(support_tag)s)" % d)
            
if __name__ == "__main__":
    gettext.bindtextdomain("update-manager", "/usr/share/locale")
    gettext.textdomain("update-manager")

    try:
        locale.setlocale(locale.LC_ALL, "")
    except:
        pass

    parser = OptionParser()
    #FIXME: Workaround a bug in optparser which doesn't handle unicode/str
    #       correctly, see http://bugs.python.org/issue4391
    #       Should be resolved by Python3
    enc = locale.getpreferredencoding()
    parser.add_option("", "--show-unsupported",
                      action="store_true", default=False,
                      help=_("Show unsupported packages on this machine").decode(enc))
    parser.add_option("", "--show-supported",
                      action="store_true", default=False,
                      help=_("Show supported packages on this machine").decode(enc))
    parser.add_option("", "--show-all",
                      action="store_true", default=False,
                      help=_("Show all packages with their status").decode(enc))
    parser.add_option("", "--list",
                      action="store_true", default=False,
                      help=_("Show all packages in a list").decode(enc))

    (options, args) = parser.parse_args()

    # packages that are not downloadable
    no_candidate = set()

    # packages that we have no support information
    unsupported = set()

    # dict with pkgname : support time
    supported_time_for_pkgname = {}

    # dict with supporttime : set of packagenames
    supported_by_time = {}

    # total count, for statistics
    total = 0

    # analyize
    cache = apt.Cache()
    for pkg in cache:
        if pkg.is_installed:
            total += 1
            if not pkg.candidate or not pkg.candidate.downloadable:
                no_candidate.add(pkg.name)
                continue
            if not "Supported" in pkg.candidate.record:
                unsupported.add(pkg.name)
                continue
            # get support time
            support_tag = pkg.candidate.record["Supported"]
            (still_supported, support_str) = get_maintenance_status(cache, pkg.name, support_tag)
            if not still_supported:
                unsupported.add(pkg.name)
                continue
            supported_time_for_pkgname[pkg.name] = support_tag
            if not support_str in supported_by_time:
                supported_by_time[support_str] = set()
            supported_by_time[support_str].add(pkg.name)

    has_esm = False
    for source in SourcesList().list:
        if 'esm.ubuntu.com' in source.uri:
            has_esm = True

    ESM_message = N_(
"""This Ubuntu 12.04 LTS system is past its End of Life, and is no longer
receiving security updates.  To protect the integrity of this system, it's
critical that you enable Extended Security Maintenance updates:
 * https://www.ubuntu.com/esm
""")

    if not has_esm:
        print _(ESM_message)

    # output
    print _("Support status summary of '%s':") % os.uname()[1]
    print
    for (time, tset) in supported_by_time.iteritems():
        print _("You have %(num)s packages (%(percent).1f%%) supported until %(time)s") % { 
            'num' : len(tset),
            'percent' : len(tset) * 100.0 / total,
            'time' : time}
    print

    print _("You have %(num)s packages (%(percent).1f%%) that can not/no-longer be downloaded") % {
        'num' : len(no_candidate),
        'percent' : len(no_candidate) * 100.0 / total}
    print _("You have %(num)s packages (%(percent).1f%%) that are unsupported") % {
        'num' : len(unsupported),
        'percent' : len(unsupported) * 100.0 / total}

    # provide the support status info as well
    if os.path.exists("/usr/bin/hwe-support-status"):
        print("")
        subprocess.call(["/usr/bin/hwe-support-status"])

    if not (options.show_unsupported or
            options.show_supported or
            options.show_all):
        print
        print _("Run with --show-unsupported, --show-supported or --show-all to see more details")

    if options.show_unsupported or options.show_all:
        print
        print _("No longer downloadable:")
        print twrap(" ".join(sorted(no_candidate)))
        
        print _("Unsupported: ")
        print twrap(" ".join(sorted(unsupported)))
    
    if options.show_supported or options.show_all:
        for (time, tset) in supported_by_time.iteritems():
            print _("Supported until %s:") % time
            print twrap(" ".join(sorted(tset)))

    if options.list:
        pkg = max(cache, key=lambda pkg: pkg.is_installed and len(pkg.name))
        field_width = len(pkg.name)
        format_str = "%-"+str(field_width)+"s  %s"
        for pkg in sorted(cache, cmp=lambda a,b: cmp(a.name, b.name)):
            if pkg.is_installed:
                support =  supported_time_for_pkgname.get(pkg.name, _("Unsupported"))
                print format_str % (pkg.name, support)