#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# deluge_webserver.py
#
# Copyright (C) Martijn Voncken 2007 <mvoncken@gmail.com>
#
# 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, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, write to:
#     The Free Software Foundation, Inc.,
#     51 Franklin Street, Fifth Floor
#     Boston, MA  02110-1301, USA.
#
#  In addition, as a special exception, the copyright holders give
#  permission to link the code of portions of this program with the OpenSSL
#  library.
#  You must obey the GNU General Public License in all respects for all of
#  the code used other than OpenSSL. If you modify file(s) with this
#  exception, you may extend this exception to your version of the file(s),
#  but you are not obligated to do so. If you do not wish to do so, delete
#  this exception statement from your version. If you delete this exception
#  statement from all source files in the program, then also delete it here.


from webserver_common import TORRENT_KEYS, STATE_MESSAGES
import webserver_common as ws
from webserver_framework import *


import webpy022 as web
from webpy022.http import seeother, url
from webpy022.utils import Storage

from md5 import md5
import base64
from deluge.common import fsize
from operator import attrgetter

#utils:
def check_pwd(pwd):
    m = md5()
    m.update(ws.config.get('pwd_salt'))
    m.update(pwd)
    return (m.digest() == ws.config.get('pwd_md5'))

def get_torrent_status(torrent_id):
    """
    helper method.
    enhance ws.proxy.get_torrent_status with some extra data
    """
    status = ws.proxy.get_torrent_status(torrent_id,TORRENT_KEYS)
    status["id"] = torrent_id

    #for naming the status-images
    status["calc_state_str"] = "downloading"
    if status["paused"]:
        status["calc_state_str"] = "inactive"
    elif status["is_seed"]:
        status["calc_state_str"] = "seeding"

    #action for torrent_pause
    if status["calc_state_str"] == "inactive":
        status["action"] = "start"
    else:
        status["action"] = "stop"

    if status["paused"]:
        status["message"] = _("Paused %s%%") % status['progress']
    else:
        status["message"] = "%s %i%%" % (STATE_MESSAGES[status["state"]]
        , status['progress'])

    #add some pre-calculated values
    status.update({
        "calc_total_downloaded"  : (fsize(status["total_done"])
            + " (" + fsize(status["total_download"]) + ")"),
        "calc_total_uploaded": (fsize(status['uploaded_memory']
            + status["total_payload_upload"]) + " ("
            + fsize(status["total_upload"]) + ")"),
    })

    return Storage(status) #Storage for easy templating.

#/utils

#routing:
urls = (
    "/login(.*)", "login",
    "/index(.*)", "index",
    "/torrent/info/(.*)", "torrent_info",
    "/torrent/pause(.*)", "torrent_pause",
    "/torrent/add(.*)", "torrent_add",
    "/torrent/delete/(.*)", "torrent_delete",
    "/torrent/queue/up/(.*)", "torrent_queue_up",
    "/torrent/queue/down/(.*)", "torrent_queue_down",
    "/pause_all(.*)", "pause_all",
    "/resume_all(.*)", "resume_all",
    "/refresh/set(.*)", "refresh_set",
    "/refresh/(.*)", "refresh",
    "/home(.*)", "home",
    "/about(.*)", "about",
    #default-pages
    "/", "login",
    "", "login",
    #remote-api:
    "/remote/torrent/add(.*)", "remote_torrent_add"
)

#/routing

#pages:
class login:
    @deluge_page_noauth
    def GET(self, name):
        vars = web.input(error = None)
        return ws.render.login(vars.error)

    def POST(self, name):
        vars = web.input(pwd = None ,redir = None)

        if check_pwd(vars.pwd):
            #start new session
            start_session()
            do_redirect()
        elif vars.redir:
            seeother(url('/login',error=1,redir=vars.redir))
        else:
            seeother('/login?error=1')

class home:
    @check_session
    def GET(self, name):
        do_redirect()

class index:
    "page containing the torrent list."
    @auto_refreshed
    @deluge_page
    def GET(self, name):
        vars = web.input(sort=None, order=None)

        status_rows = [get_torrent_status(torrent_id)
            for torrent_id in ws.proxy.get_torrent_state()]

        #sorting:
        if vars.sort:
            status_rows.sort(key=attrgetter(vars.sort))
            if vars.order == 'up':
                status_rows = reversed(status_rows)

            setcookie("order", vars.order)
            setcookie("sort", vars.sort)

        return ws.render.index(status_rows)

class torrent_info:
    "torrent details"
    @auto_refreshed
    @deluge_page
    def GET(self, torrent_id):
        return ws.render.torrent_info(get_torrent_status(torrent_id))

class torrent_pause:
    "start/stop a torrent"
    @check_session
    def POST(self, name):
        vars = web.input(stop = None, start = None, redir = None)
        if vars.stop:
            ws.proxy.pause_torrent(vars.stop)
        elif vars.start:
            ws.proxy.resume_torrent(vars.start)

        do_redirect()

class torrent_add:
    @deluge_page
    def GET(self, name):
        return ws.render.torrent_add()

    @check_session
    def POST(self, name):
        vars = web.input(url = None, torrent = {})

        if vars.url and vars.torrent.filename:
            error_page(_("Choose an url or a torrent, not both."))
        if vars.url:
            ws.proxy.add_torrent_url(vars.url)
            do_redirect()
        elif vars.torrent.filename:
            data = vars.torrent.file.read()
            data_b64 = base64.b64encode(data)
            #b64 because of strange bug-reports related to binary data
            ws.proxy.add_torrent_filecontent(vars.torrent.filename,data_b64)
            do_redirect()
        else:
            error_page(_("no data."))

class remote_torrent_add:
    """
    For use in remote scripts etc.
    POST pwd and torrent
    """
    @remote
    def POST(self, name):
        vars = web.input(pwd = None, torrent = {})

        if not check_pwd(vars.pwd):
            return 'error:wrong password'

        data_b64 = base64.b64encode(vars.torrent.file.read())
        ws.proxy.add_torrent_filecontent(vars.torrent.filename,data_b64)
        return 'ok'

class torrent_delete:
    @deluge_page
    def GET(self, torrent_id):
        return ws.render.torrent_delete(get_torrent_status(torrent_id))

    @check_session
    def POST(self, name):
        torrent_id = name
        vars = web.input(data_also = None, torrent_also = None)
        data_also = bool(vars.data_also)
        torrent_also = bool(vars.torrent_also)
        ws.proxy.remove_torrent(torrent_id, data_also, torrent_also)
        do_redirect()


class torrent_queue_up:
    @check_session
    def POST(self, name):
        torrent_id = name
        ws.proxy.queue_up(torrent_id)
        do_redirect()

class torrent_queue_down:
    @check_session
    def POST(self, name):
        torrent_id = name
        ws.proxy.queue_down(torrent_id)
        do_redirect()

class pause_all:
    @check_session
    def POST(self, name):
        for torrent_id in ws.proxy.get_torrent_state():
            ws.proxy.pause_torrent(torrent_id)
        do_redirect()

class resume_all:
    @check_session
    def POST(self, name):
        for torrent_id in ws.proxy.get_torrent_state():
            ws.proxy.resume_torrent(torrent_id)
        do_redirect()

class refresh:
    @check_session
    def POST(self, name):
        auto_refresh = {'off':'0', 'on':'1'}[name]
        setcookie('auto_refresh',auto_refresh)
        do_redirect()

class refresh_set:
    @deluge_page
    def GET(self, name):
        return ws.render.refresh_form()

    @check_session
    def POST(self, name):
        vars = web.input(refresh = 0)
        refresh = int(vars.refresh)
        if refresh > 0:
            setcookie('auto_refresh','1')
            setcookie('auto_refresh_secs', str(refresh))
            do_redirect()
        else:
            error_page(_('refresh must be > 0'))

class about:
    @deluge_page_noauth
    def GET(self, name):
        return ws.render.about()

#/pages


def WebServer():
    return create_webserver(urls, globals())

def run():
    server = WebServer()
    try:
        server.start()
    except KeyboardInterrupt:
        server.stop()

if __name__ == "__main__":
    run()