"""
    Handling page requests
"""

# for filesystem ops
import os, os.path

# for ResponseError
import http

# for TemplatePage
import template

from page_tree import page_tree

# path to directory containing the page heirarcy
PAGE_DIR = "pages"

class PageError (http.ResponseError) :
    """
        Error looking up/handling a page
    """

    pass

# XXX: should inherit from PageInfo
class Page (object) :
    """
        This object represents the information about our attempt to render some specific page
    """

    def __init__ (self, url, path, basename, url_tail) :
        """
            Initialize the page at the given location

            @param url the URL leading to this page
            @param path the filesystem path to this page's file
            @param basename the filesystem name of this page's file, without the file extension
            @param url_trail trailing URL for this page
        """
        
        # store
        self.url = url
        self.path = path
        self.basename = basename
        self.url_tail = url_tail

        # unbound
        self.request = None

        # sub-init
        self._init()

    def _init (self) :
        """
            Do initial data loading, etc
        """
        
        pass

    def bind_request (self, request) :
        """
            Bind this page-render to the given request
        """

        self.request = request

    @property
    def title (self) :
        """
            Return the page's title

            Defaults to the retreiving the page title from page_list, or basename in Titlecase.
        """
        
        # lookup in page_list
        page_info = page_tree.get_page(self.url)
        
        # fallback to titlecase
        if page_info :
            title = page_info.title

        else :
            title = self.basename.title()

        return title
    
    @property
    def content (self) :
        """
            Return the page content as a string
        """

        abstract

class HTMLPage (Page) :
    """
        A simple .html page that's just passed through directly
    """

    @property
    def content (self) :
        """
            Opens the .html file, reads and returns contents
        """

        return open(self.path, 'rb').read()

class TemplatePage (Page) :
    """
        A template that's rendered using our template library
    """
    
    @property
    def content (self) :
        """
            Loads the .tmpl file, and renders it
        """

        return template.render_file(self.path,
            request     = self.request,
            page_tree   = page_tree
        )

# list of page handlers, by type
TYPE_HANDLERS = [
    ('html',                    HTMLPage        ),
    (template.TEMPLATE_EXT,     TemplatePage    ),
]

def _lookup_handler (url, path, filename, basename, extension, tail) :
    """
        We found the file that we looked for, now get its handler
    """

    # find appropriate handler
    for handler_ext, handler in TYPE_HANDLERS :
        # match against file extension?
        if handler_ext == extension :
            # found handler, return instance
            return handler(url, path, basename, tail)

    # no handler found
    raise PageError("No handler found for page %r of type %r" % (url, extension))

def lookup (name) :
    """
        Look up and return a Page object for the given page, or raise an error
    """

    # inital path
    path = PAGE_DIR
    url_segments = []

    # name segments
    segments = name.split('/')

    # iterate through the parts of the page segments
    while True :
        segment = None

        # pop segment
        if segments :
            segment = segments.pop(0)

            url_segments.append(segment)

        # translate empty -> index
        if not segment :
            segment = 'index'

        # look for it in the dir
        for filename in os.listdir(path) :
            # build full file path
            file_path = os.path.join(path, filename)

            # stat, recurse into subdirectory?
            if os.path.isdir(file_path) and filename == segment :
                # use new dir
                path = file_path

                # break for-loop to look at next segment
                break
 
            # split into basename + extension
            basename, extension = os.path.splitext(filename)

            # ...remove that dot
            extension = extension.lstrip('.')
            
            # match against requested page name?
            if basename == segment :
                # found the file we wanted
                return _lookup_handler('/'.join(url_segments), file_path, filename, basename, extension, '/'.join(segments))
            
            else :
                # inspect next file in dir
                continue

        else :
            # did not find any dir or file, break out of while loop
            break

    # did not find the filename we were looking for in os.listdir
    raise PageError("Page not found: %s" % name, status='404 Not Found')