# -*- python -*-
import __main__, logging, iso8601, time
import dbagg, dbagg.scan, dbagg.web, rssfinder

class ManageSourcesPage(dbagg.web.AggPage):
    templateFile      = 'manage_sources.html.tmpl'

    # TODO: Need pop-up version of quick subscribing
    # TODO: Need various sorting options on list of feeds

    def initialize(self, *args, **kwargs):
        self.log     = logging.getLogger("%s"%self.__class__)
        self.conn    = kwargs['conn']
        self.sources = kwargs['sources']        
        self.items   = kwargs['items']

    def wmfactory_action(self, request):
        for k in request.args.keys():
            try:
                (label, opt) = k.split('|')
                if label == 'action':
                    return opt
            except ValueError:
                pass
        return request.args.get('action', ['none'])[0]
    
    def wmfactory_source_id(self, request):
        return request.args.get('source_id')
    def wmfactory_url(self, request):
        return request.args.get('url', [''])[0]
    
    def wmfactory_max_sources(self, request):
        return int(request.args.get('max_sources', ['500'])[0])
    def wmfactory_offset_sources(self, request):
        return int(request.args.get('offset_sources', ['0'])[0])        
    
    def wmfactory_sources_count(self, request):
        cursor = self.conn.cursor()
        cursor.execute( \
            """
            SELECT sources.*
            FROM sources
                LEFT JOIN sources_meta AS t_hidden
                    ON (t_hidden.source=sources.id AND t_hidden.name="hidden")
            WHERE
                (t_hidden.value IS null OR t_hidden.value='0')
                """)

        return "%s" % (cursor.rowcount)
        
    def wmfactory_sources(self, request):
        sources_per_page = self.wmfactory_max_sources(request)
        offset_sources   = self.wmfactory_offset_sources(request)
        
        source_list = []
        curr_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')
            ORDER BY
                sources.title
            LIMIT %s OFFSET %s
            """,
            ( sources_per_page, offset_sources ) );
        
        for curr_source in curr_sources:
            source_list.append(dbagg.web.SourceModel(sources=self.sources, \
                                                     items=self.items, \
                                                     source=curr_source))

        return source_list

    def addAction(self, request):
        url = self.wmfactory_url(request)

        feeds = []
        try:    feeds = rssfinder.getFeeds(url)
        except: pass
        
        if len(feeds) > 1:
            self.displayMessage(request, "Multiple feeds found, please pick one.")
            for f in feeds:
                self.displayMessage(request, "Found feed: %s" % (f))
        elif len(feeds) > 0:
            new_id = self.sources.add_url(feeds[0])
            new_source = self.sources.get_source(new_id)
            
            main_app = __main__.main_app
            source_scanner = main_app.getServiceNamed('source_scanner')
            source_scanner.queueSource(new_source)

            self.displayMessage(request, "Added/updated feed: %s (%s)" % (new_source.title, new_id))
        else:
            self.displayMessage(request, "No feeds found for %s" % (url))
        
    def deleteAction(self, request):
        ids = request.args.get('source_id', [])
        for id in ids:
            curr_source = self.sources.get_source(id)
            if not curr_source is None:
                items = self.items.items_for_source(curr_source)
                item_count = 0
                for curr_item in items:
                    item_count = item_count + 1
                    self.items.delete_item(curr_item)
                self.sources.delete_source(curr_source)
                self.displayMessage(request, \
                                    "Deleted source %s (#%s) and %s associated items.  %s" \
                                    % (curr_source.title, id, item_count, curr_source.url))

    def scanAction(self, request):
        ids = request.args.get('source_id', [])
        for id in ids:
            curr_source = self.sources.get_source(id)
            if not curr_source is None:        
                main_app = __main__.main_app
                source_scanner = main_app.getServiceNamed('source_scanner')
                source_scanner.queueSource(curr_source)
        
                self.displayMessage(request, \
                                    "Scheduled scan for source %s (#%s)" \
                                    % (curr_source.title, curr_source.id))

    def renderView(self, request):
        action = self.wmfactory_action(request)        
        act = getattr(self, "%sAction" % (action), None)
        if act: act(request)
        return dbagg.web.AggPage.renderView(self, request)

################################################################################

resource = ManageSourcesPage(conn=__main__.conn, \
                             sources=__main__.sources, \
                             items=__main__.items)