#!/usr/bin/python 

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


import gi
gi.require_version('WebKit', '3.0')
from gi.repository import GObject, Gtk, Gdk, WebKit
import os, sys, re
import json
from time import sleep

import ConfigParser



class Accept(object):

    window = None
    view = None

    def __init__(self):

        main_loop = GObject.MainLoop()


        display = Gdk.Display.get_default()
        screen = display.get_default_screen()
        screen_width = screen.get_width()
        screen_height = screen.get_height()


        self.window = Gtk.Window(Gtk.WindowType.TOPLEVEL)
        self.window.connect("destroy", Gtk.main_quit)
        self.window.app_paintable = True
        self.window.set_default_size(screen_width, screen_height)


	#this line changes to scrollbar enabled window
        self.scrolled_window = Gtk.ScrolledWindow()
        #default# self.scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC,Gtk.PolicyType.AUTOMATIC) 


        #self.window.realize()
        self.window.fullscreen()
        #self.window.activate_focus()
        #self.window.present()

        #if there is no window manager there is no default cursor 
        #cursor = Gdk.Cursor(Gdk.CursorType.ARROW)
        #gdk_window = self.window.get_root_window()
        #gdk_window.set_cursor(cursor)

        self.view = WebKit.WebView()
        settings = self.view.get_settings()
        settings.set_property('enable-default-context-menu',False);

        accept_url = self.getUrl()
        if ( accept_url == "error" ):
            self.acceptExit(33,"no url specificed in config file")

        '''
        f = open(root_web_dir + "/index.html", 'r')
        self.view.load_html_string(
            f.read(), "file://%s/" % root_web_dir)
        f.close()
        '''

        #self.view.load_uri("file://" + root_web_dir + "/"+theme+"/index.html")
        self.view.load_uri(accept_url);

        #self.view.connect("resource-response-received", self.webkit_response_received_cb)
        #self.view.connect("resource-load-failed", self.webkit_load_failed_cb)
        self.view.connect('load-error', self.load_error_cb)

        self.view.connect("navigation-policy-decision-requested", self.navigation_cb)

        # need to wait until document is loaded before running webkit execute_script call, otherwise we get "ReferenceError: Can't find variable"
        self.view.connect("document-load-finished", self.webkit_document_load_finished_cb)

        #these 2 lines change to scrollbar enabled window
        self.scrolled_window.add(self.view)
        self.window.add(self.scrolled_window)
	#old non-scrollbar enabled window:
        #self.window.add(self.view)


        self.window.show_all()
        
        #key to getting focus so blinking cursors appear without clicking somewhere first in lightdm
        self.window.present()


        #can't do this too quick, must wait until webkit initialized, otherwise we get: "ReferenceError: Can't find variable" during execute_script call
        #self.init_timer_value=100
        #self.greeter.timeout_id=GObject.timeout_add(self.init_timer_value, self.get_pacrez_status, False ) 

        self.timeOut=self.getTimeout()
        #self.greeter.timeout_id=GObject.timeout_add(self.repeat_timer_value, self.get_pacrez_status, True ) 
        if (self.timeOut > 0 ):
            #wrong# self.greeter.timeout_id=GObject.timeout_add(self.timeOut, self.acceptExit(34,"timeout reached")) 
            self.timeout_id=GObject.timeout_add(self.timeOut, self.acceptExit,34,"timeout reached") 


        main_loop.run()

    def acceptExit(self,code,message):
         self.log("exiting: "+message);
         exit(code)
         #Gtk.main_quit

    def getTimeout(self):
        try:
            config=ConfigParser.ConfigParser()
            config.read("/etc/groovix/accept.conf")
            timeout=config.getint('accept','timeout')
            return timeout

        except:
            pass
    
        return 0;

    def getUrl(self):
        try:
            config=ConfigParser.ConfigParser()
            config.read("/etc/groovix/accept.conf")
            acceptUrl=config.get('accept','mainurl')
            return acceptUrl

        except:
            pass
    
        return ("error");


    def webkit_document_load_finished_cb(self,view,frame):
            # if we need to do any javascript, it must be done after webkit is loaded
            self.log ("pre response")
            response = frame.get_network_response()
            self.log ("post response")

            #uri = response.get_uri()
            #print ('Response uri:' + str(uri))

            message = response.get_message()
            status_code=message.props.status_code
            self.log ('Response Code:' + str(status_code))
            if (status_code < 200 or status_code >= 300 ) :
                  self.acceptExit(21,"http response code: "+str(status_code) );

            #if message:
            #    print ('message method:' + str(message.props.method))
            #    print ('message uri:' + str(message.props.uri))
            #    print ('message http_version:' + str(message.props.http_version))
            #    print ('message flags:' + str(message.props.flags))
            #    print ('message server_side:' + str(message.props.server_side))
            #    print ('message status_code:' + str(message.props.status_code))
            #    print ('message reason_phrase:' + str(message.props.reason_phrase))
            #    print ('message first_party:' + str(message.props.first_party))
            #    print ('message request_body:' + str(message.props.request_body))
            #    print ('message request_headers:' + str(message.props.request_headers))
            #    print ('message tls_certificate:' + str(message.props.tls_certificate))
            #    print ('message tls_errors:' + str(message.props.tls_errors))

       

    # left in here to show example of how to execute javascript from python
    def show_message_cb(self, greeter, text, type):
        self.log("show_message_cb "+text)
        self.view.execute_script("show_message(%s);" % json.dumps(text))


    #def webkit_load_failed_cb(self, view, frame, resource, error, data=None):
    #    self.log("error is "+str(error))

    #def webkit_response_received_cb(self, view, frame, resource, response, data=None):
    #    self.log("response is "+str(self.webkit_network_response_get_message(response)))

    def load_error_cb(self, web_view, web_frame, uri, web_error):
            self.log ('ERROR LOADING URL: '+ str(web_error))
            self.acceptExit(22,str(web_error) );

    def navigation_cb(self, view, frame, req, navAct, polDec, data=None):
        uri = req.get_uri()
        scheme, path=uri.split(':', 1)
        if scheme == 'gaccept':
            answer=path
            self.log("accept answer is %s" % answer)
            if answer=="yes":
                self.acceptExit(0,"accepted");
            else:
                self.acceptExit(31,"not accepted");
        else:
            # means that it is a true navigation request, let it go through
            return False

    def log(self, text):
        print >> sys.stderr, "groovix-accept-use log: "+text

    #self.view.connect("context-menu", self.right_click_cb)
    def right_click_cb(self, view, menu, htr, twk, data=None):
            self.log("right click")
            return True



if __name__ == '__main__':
    Accept()
    Gtk.main()

