import os
import gtk
from datetime import datetime
from cmislib import CmisClient
from cmislib.exceptions import UpdateConflictException, ObjectNotFoundException
from urllib2 import URLError
import pygtk
pygtk.require('2.0')


class CheckButton:
    verbose = True
    upload_dir = None
    log_file = None
    num_file_errors = 0

    def start_upload(self, button):
        print('starting upload')
        api_url = 'http://localhost:8080/'
        api_url = api_url + 'alfresco/api/-default-/public/cmis/versions/1.1/atom'
        api_user = 'admin'
        api_password = 'admin'
        start_time = datetime.now()
        create_structure_boolean = True
        upload_files_boolean = True
        self.log_file = open(str(self.upload_dir) + '.log', 'w')
        client = CmisClient(api_url, api_user, api_password)
        try:
            default_repo = client.defaultRepository
            if create_structure_boolean:
                self.create_dir_schema(default_repo)
            if upload_files_boolean:
                self.upload_files(default_repo)
            stop_time = 'Total time: ' + str(datetime.now() - start_time)
            self.print_and_log('Number of file errors: ' + str(self.num_file_errors))
            self.print_and_log(stop_time)
            if self.verbose:
                print stop_time
            self.log_file.close()
        except URLError:
            print('Can not connect to the server.')
            quit()

    # Our callback.
    # The data passed to this method is printed to stdout

    def callback(self, widget, data=None):
        print "%s was toggled %s" % (data, ("OFF", "ON")[widget.get_active()])

    # This Opens the dialog for select the folder.
    def OpenDialog(self, button):
        dialog = gtk.FileChooserDialog("Open..", None, gtk.FILE_CHOOSER_ACTION_OPEN, (
            gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK))
        dialog.set_default_response(gtk.RESPONSE_OK)
        dialog.set_action(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
        dialog.set_select_multiple(True)
        filter = gtk.FileFilter()
        filter.set_name("All files")
        filter.add_pattern("*")
        dialog.add_filter(filter)
        filter = gtk.FileFilter()
        filter.set_name("Images")
        filter.add_mime_type("image/png")
        filter.add_mime_type("image/jpeg")
        filter.add_mime_type("image/gif")
        filter.add_pattern("*.png")
        filter.add_pattern("*.jpg")
        filter.add_pattern("*.gif")
        filter.add_pattern("*.tif")
        filter.add_pattern("*.xpm")
        dialog.add_filter(filter)
        response = dialog.run()
        if response == gtk.RESPONSE_OK:
            self.upload_dir = dialog.get_filename()
            os.chdir('/'.join(dialog.get_filename().split('/')[:-1]) + '/')
            self.real_dir = os.getcwd()
            print dialog.get_filename(), 'selected'
        elif response == gtk.RESPONSE_CANCEL:
            self.print_and_log('Closed, no files selected')
        dialog.destroy()

    def print_and_log(self, string):
        if self.verbose:
            print(string)
        self.log_file.write(string + '\n')

    def dir_exists(self, dir_name, default_repo):
        try:
            dir_obj = default_repo.getObjectByPath(dir_name)
            return dir_obj
        except ObjectNotFoundException:
            return False

    def create_dir_schema(self, default_repo):
        self.print_and_log("Creating directoy schema")
        dirs = []
        dirs_created = []  # array to know if the dir has already been created
        # Creating an array of all directories and subdirectories
        for directory, subdirectories, files in os.walk(self.upload_dir):
            dirs.append(directory)
        # print dirs
        for full_dir in dirs:
            full_dir = full_dir.split(self.real_dir)[-1][1:]
            print full_dir
            last_dir = os.sep  # tmp var to hold last dir
            for actual_dir in full_dir.split(os.sep):
                full_actual = last_dir + actual_dir
                exists = self.dir_exists(full_actual, default_repo)
                if not exists and last_dir not in dirs_created:
                    try:
                        last_parent = default_repo.getObjectByPath(last_dir)
                        last_parent.createFolder(actual_dir)
                        # self.print_and_log('Creating ' + actual_dir)
                    except UpdateConflictException:
                        self.print_and_log(actual_dir + ' already exists.')
                    except ObjectNotFoundException:
                        self.print_and_log(actual_dir + ' not found.')
                last_dir = last_dir + actual_dir + os.sep
                dirs_created.append(last_dir + actual_dir)

    def upload_files(self, default_repo):
        self.print_and_log("Uploading files.")
        for directory, subdirectories, files in os.walk(self.upload_dir):
            for file in files:
                try:
                    someFile = open(directory + os.sep + file, 'r')
                    directory_temp = directory.split(self.real_dir)[-1][1:]
                    print str(directory)
                    print str(directory_temp)
                    folder = default_repo.getObjectByPath(os.sep + directory_temp)
                    folder.createDocument(file, contentFile=someFile)
                except UpdateConflictException:
                    self.print_and_log(file + ' already exists.')
                    self.num_file_errors = self.num_file_errors + 1
                except URLError:
                    self.print_and_log(file + ' generates URL error.')
                    self.num_file_errors = self.num_file_errors + 1
                except UnicodeDecodeError:
                    self.print_and_log(file + ' generates Unicode decode error.')
                    self.num_file_errors = self.num_file_errors + 1
                except ObjectNotFoundException:
                    self.print_and_log(file + ' object not found error.')
                    self.num_file_errors = self.num_file_errors + 1

    def delete_event(self, widget, event, data=None):
        gtk.main_quit()
        return False

    def __init__(self):

        # Create a new window
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)

        # Set the window title
        self.window.set_title("Alfresco Uploader")

        # Set a handler for delete_event that immediately
        # exits GTK.
        self.window.connect("delete_event", self.delete_event)

        # Sets the border width of the window.
        self.window.set_border_width(40)

        # Create a vertical box
        vbox = gtk.VBox(True, 2)

        # Put the vbox in the main window
        self.window.add(vbox)

        # Create first button
        button = gtk.CheckButton("Create Structure")

        # When the button is toggled, we call the "callback" method
        # with a pointer to "button" as its argument
        button.connect("toggled", self.callback, "check button 1")

        # Insert button 1
        vbox.pack_start(button, True, True, 2)

        button.show()

        # Create second button

        button = gtk.CheckButton("Upload Directory")

        # When the button is toggled, we call the "callback" method
        # with a pointer to "button 2" as its argument
        button.connect("toggled", self.callback, "check button 2")
        # Insert button 2
        vbox.pack_start(button, True, True, 2)

        button.show()

        # Create "GO" button
        SelectFolderButton = gtk.Button("Select Folder")

        # When the button is clicked, we call the opendialog function
        # and the program opens the dialog
        SelectFolderButton.connect("clicked", self.OpenDialog)

        # Insert the GO button
        vbox.pack_start(SelectFolderButton, True, True, 2)

        StartUploadButton = gtk.Button("Start Upload")
        StartUploadButton.connect("clicked", self.start_upload)

        # Insert the GO button
        vbox.pack_start(StartUploadButton, True, True, 2)

        # Create "Quit" button
        button = gtk.Button("Quit")

        # When the button is clicked, we call the mainquit function
        # and the program exits
        button.connect("clicked", lambda wid: gtk.main_quit())

        # Insert the quit button
        vbox.pack_start(button, True, True, 2)

        SelectFolderButton.show()
        StartUploadButton.show()
        button.show()
        vbox.show()
        self.window.show()


def main():
    gtk.main()
    return 0


if __name__ == "__main__":
    CheckButton()
    main()