# -*- python -*-
import __main__, dbagg, logging, iso8601, time, dbagg.web
from spambayes import hammie

# DONE: Do not show already viewed items
# DONE: Need a way to not show the description disclosure triangle if no description present

# TODO: Consider iframe/css driven on-demand display of archived items
# TODO: Display sources without new items, provide drill-down to archived items
# TODO: Make Bayesian scores a part of a plugin, think about plugin contributions to item display

class BayesItemModel(dbagg.web.ItemModel):
    def wmfactory_trained(self, request):
        trained = self.item.get_meta("bayes:trained")
        if not trained: trained = 'none'
        return trained
    def wmfactory_score(self, request):
        score = self.item.get_meta("bayes:score")
        if score: score = "%0.3f" % (float(score))
        return self.default_blank(score)

class BayesSourceIndexPage(dbagg.web.AggPage):
    templateFile      = 'bysources_bayes.html.tmpl'

    def initialize(self, *args, **kwargs):
        self.log         = logging.getLogger("%s"%self.__class__)
        self.conn        = kwargs['conn']
        self.sources     = kwargs['sources']        
        self.items       = kwargs['items']
        self.classifier  = kwargs['classifier']
                
    def wvupdate_selected(self, request, widget, model):
        if widget.node.attributes.get('value', '') == str(model):
            widget.node.attributes['selected'] = 'selected'
        
    def wmfactory_total_pages(self, request):
        max_per = int(self.wmfactory_max_sources(request))
        return int(self.wmfactory_fsources_count(request)) / max_per
    
    def wmfactory_pages(self, request):
        max_per = int(self.wmfactory_max_sources(request))
        pages = []
        for n in xrange(self.wmfactory_total_pages(request)):
            pages.append({'page':n+1, 'offset':n*max_per})
        return pages
        
    def wmfactory_max_sources(self, request):
        return int(request.args.get('max_sources', ['200'])[0])
    
    def wmfactory_offset_sources(self, request):
        return int(request.args.get('offset_sources', ['0'])[0])
    
    def wmfactory_max_per_source(self, request):
        return int(request.args.get('max_per_source', ['20'])[0])
    def wmfactory_max_age(self, request):
        return float(request.args.get('max_age', 12)[0])
    def wmfactory_since(self, request):
        since = request.args.get('since', [None])[0]
        if since is not None: return since        
        max_age = self.wmfactory_max_age(request)
        return iso8601.ctime(time.time() - (60*60*max_age))
        
    def wmfactory_fsources_count(self, request):
        since     = self.wmfactory_since(request)
        
        cursor = self.conn.cursor()
        cursor.execute( \
            """
            SELECT count(*)
            FROM sources_meta
            WHERE (name="last_updated" AND value > %s)
            """,
            ( since ) );
        count = cursor.fetchone()[0]

        return count

    def wmfactory_fitems_count(self, request):
        since     = self.wmfactory_since(request)
        
        cursor = self.conn.cursor()
        cursor.execute( \
            """
            SELECT count(items.id)
            FROM items
                LEFT JOIN items_meta AS b ON (b.item=items.id AND b.name="hidden")
            WHERE
                (b.value IS null OR b.value='0') AND
                items.created>%s
            """,
            ( since ) );
        count = cursor.fetchone()[0]

        return count
    
    def wmfactory_fsources(self, request):
        max_sources    = self.wmfactory_max_sources(request)
        offset_sources = self.wmfactory_offset_sources(request)
        max_per_source = self.wmfactory_max_per_source(request)        
        since          = self.wmfactory_since(request)

        filtered_sources = self.sources.sql_iter( \
            """
            SELECT sources.*
            FROM sources
                LEFT JOIN sources_meta AS t_hidden
                    ON (t_hidden.source=sources.id AND t_hidden.name="hidden")
                LEFT JOIN sources_meta AS t_updated
                    ON (t_updated.source=sources.id AND t_updated.name="last_updated")
            WHERE
                (t_hidden.value IS null OR t_hidden.value='0') AND
                (t_updated.value > %s)
            ORDER BY
                t_updated.value DESC
            LIMIT %s OFFSET %s
            """,
            ( since, max_sources, offset_sources ) );

        pair_list = []
        curr_source = None
        curr_pair = None

        # TODO: Needs to be an option whether shown/visited items are hidden
        for curr_source in filtered_sources:
            curr_pair = { 'source':dbagg.web.SourceModel(sources=self.sources, \
                                               items=self.items, \
                                               source=curr_source),
                          'items':[] }

            curr_items = self.items.sql_iter( \
                """
                SELECT *
                FROM items
                    LEFT JOIN items_meta AS t_hidden
                        ON (t_hidden.item=items.id AND t_hidden.name="hidden")
                    LEFT JOIN items_meta AS t_shown_at
                        ON (t_shown_at.item=items.id AND t_shown_at.name="shown_at")
                    LEFT JOIN items_meta AS t_visited_at
                        ON (t_visited_at.item=items.id AND t_visited_at.name="visited_at")
                WHERE
                    (source=%s AND created>%s)
                    AND
                    (t_hidden.value IS null OR t_hidden.value='0')
                    AND
                    (t_shown_at.value IS null)
                    AND
                    (t_visited_at.value IS null)
                ORDER BY
                    items.created DESC
                LIMIT %s
                """,
                ( curr_source.id, since, max_per_source));

            for curr_item in curr_items:
                curr_pair['items'].append(
                    BayesItemModel(item=curr_item, sources=self.sources))
            if len(curr_pair['items']) > 0:                
                pair_list.append(curr_pair)

        return pair_list

################################################################################
    
resource = BayesSourceIndexPage(conn=__main__.conn, \
                                sources=__main__.sources, \
                                items=__main__.items, \
                                classifier = __main__.classifier)