#!/usr/bin/env python3
import gi
gi.require_version('Gtk','3.0')
from gi.repository import Gtk, Gdk, GLib, GdkPixbuf
import paho.mqtt.client as paho
#from simplecrypt import encrypt, decrypt
import base64
from ctypes import *
import _ctypes
from textwrap import wrap

broker = "192.168.2.16"
client = paho.Client()
port = 1883


# print("")

builder = Gtk.Builder()
builder.add_from_file("py_wrappers/Publisher.glade")
# File filter


window      = builder.get_object("windowMain")
msg         = builder.get_object("message")
key_file    = builder.get_object("openfile")
res_text    = builder.get_object("result_text")
enc_time    = builder.get_object("enc_time")
enc_size    = builder.get_object("enc_size")
enc_seq     = builder.get_object("enc_seq")
msg_len     = builder.get_object("msg_len")
msg_arr     = builder.get_object("msg_arr")
enc_401     = builder.get_object("enc_401")
enc_593     = builder.get_object("enc_593")


filterfilter1 = Gtk.FileFilter()
filterfilter1.set_name("Keys")
filterfilter1.add_pattern("*.pub")
key_file.add_filter(filterfilter1)
window.show_all() 

class mainWindowHandler:

    def u_encrypt(self, arg, enc_method):
        so_file             = enc_method
        u_enc               = CDLL(so_file)
        u_enc.main.restype  = c_double
        tmp_num             = "001"
        c_return            = u_enc.main(arg.encode('utf-8'), tmp_num.encode("utf-8"))
        #print("Python Log :  C Return ", c_return)
        _ctypes.dlclose(u_enc._handle)
        return c_return
    
    def file_handler(self, f_name, num):
        num = str(num).zfill(3)
        f = open(".cipher/"+f_name+"_"+num+".dat", "rb")
        return f.read()
    
    def payload_process(self, plain):
        enc_glob = enc_box
        cip_glob = cip_box
        print(enc_glob)
        #time_enc = self.u_encrypt(plain, key_file.get_filename())
        time_enc = self.u_encrypt(plain, enc_glob)
        #plain = self.file_handler("cipher_EES401", 7)
        plain = self.file_handler(cip_glob, 7)
        bff_text = Gtk.TextBuffer()
        bff_text.set_text(str(plain, errors="replace"))
        res_text.set_buffer(bff_text)
        enc_size.set_text(str(len(plain)))
        send_data = base64.b64encode(plain)
        return send_data, time_enc
        
    def on_windowMain_destroy(self, *args):
        Gtk.main_quit()

    def on_close_window_clicked(self, button):
        Gtk.main_quit()


    def enc_m01(self, button):
        print("Checkbox 1 Called")
        if enc_401.get_active():
            enc_593.set_sensitive(False)
        else:
            enc_593.set_sensitive(True)
            #enc_593.set_active(True)
            print("Release m02")
        global enc_box
        global cip_box
        global max_block
        # enc_box = "/home/nino/Documents/Papers/MQTT_2.0/Crypto/NTRUEncrypt_Benchmark/EES401/URG_encrypt.so"
        enc_box = "./bin/enc_401.so"
        cip_box = "ees401/cipher"
        max_block = 60
        
    def enc_m02(self, button):
        print("Checkbox 2 Called")
        if enc_593.get_active():
            enc_401.set_sensitive(False)
        else:
            enc_401.set_sensitive(True)
            print("Release m01")
        global enc_box
        global cip_box
        global max_block
        # enc_box = "/home/nino/Documents/Papers/MQTT_2.0/Crypto/NTRUEncrypt_Benchmark/EES593/URG_encrypt.so"
        enc_box = "./bin/enc_593.so"
        cip_box = "ees593/cipher"
        max_block = 86

    def on_msg_clicked(self, button):
        bff_text = Gtk.TextBuffer()
        bff_text.set_text("Loading . . . ")
        res_text.set_buffer(bff_text)
        i = 0
        my_ip = "device01"
        identifier = "&"
        f_name = "cipher"
        time_arr = []
        plain_arr = []
        cipher_arr = []
        plain = str(msg.get_text())
        # if enc_box == None:
        #     bff_text.set_text("Please Enter Message First !")
        #     res_text.set_buffer(bff_text)
        plain_original = plain
        print(plain)
        print(max_block)
        x = max_block - (len(plain)%max_block)
        plain = plain+(" "*x)
        plain_arr = wrap(plain, max_block, replace_whitespace=False, drop_whitespace=False)
        print(plain_arr)
        print("Join List Test ", ''.join(plain_arr))
        client.connect(broker,port)
        for i in range(len(plain_arr)):
            data_now, time_enc = self.payload_process(plain_arr[i])
            cipher_arr.append(data_now)
            time_arr.append(time_enc)

        enc_time.set_text(str(sum(time_arr)))
        enc_seq.set_text(str(i))
        msg_arr.set_text(str(plain_arr))
        msg_len.set_text(str(len(plain_original)))

        print(time_arr)
        print(msg.get_text())
        
        cipher_arr = b''.join(cipher_arr)
        cipher_arr = cipher_arr.decode('ascii')
        client.loop_start()
        client.publish("device01/msg", cipher_arr)
        client.loop_stop()
        # print("Your File ",key_file.get_filename())

builder.connect_signals(mainWindowHandler())
Gtk.main()