import glob
import hashlib
import os
import random
import time
from tkinter import *
from tkinter import filedialog
import schedule
from PIL import Image as p_image
from PIL import ImageFile

ImageFile.LOAD_TRUNCATED_IMAGES = True

root = Tk()
root.directory = filedialog.askdirectory()

temppwd = root.directory
os.chdir(temppwd)
ext_list = ['*.png', '*.gif', '*.jpeg', '*.jpg', "*.webm"]
root.destroy()
logf = open("failures.txt", "w")


def pil_random():
    ext_list = ['*.png', '*.jpeg', '*.jpg', '*.gif']
    for extention in ext_list:
        image_list = glob.glob(extention)
        for image in image_list:
            print(image)
            fg = p_image.open(image)
            randomize(fg, image, ''.join(fg.getbands()))


def analyseImage(path):
    '''
    Pre-process pass over the image to determine the mode (full or additive).
    Necessary as assessing single frames isn't reliable. Need to know the mode
    before processing all frames.
    '''
    im = p_image.open(path)
    results = {
        'size': im.size,
        'mode': 'full',
    }
    try:
        while True:
            if im.tile:
                tile = im.tile[0]
                update_region = tile[1]
                update_region_dimensions = update_region[2:]
                if update_region_dimensions != im.size:
                    results['mode'] = 'partial'
                    break
            im.seek(im.tell() + 1)
    except EOFError:
        pass
    return results


def set_bit(old_byte, new_bit):
    '''
        Takes a byte and alters the least significant bit.
        :param old_byte: The original Byte.
        :param new_bit: New bit value.
        '''
    b = list(bin(old_byte))
    b[-1] = str(new_bit)
    return int(''.join(b), 2)


def randomize(fg, image, mode):
    check_change_temp_start = hashlib.md5(open(image, 'rb').read()).hexdigest()
    if mode == "P":
        frame_holder = []
        mode_local = analyseImage(image)['mode']
        nframes = 0
        last_frame = fg.convert('RGBA')
        p = fg.getpalette()
        duration = fg.info['duration']
        print(duration)
        try:
            while True:
                if not fg.getpalette():
                    fg.putpalette(p)
                new_frame = p_image.new('RGBA', fg.size)
                for row in range(int(fg.size[1] / 16)):
                    for col in range(int(fg.size[0] / 16)):
                        rbga_bitswap(col, new_frame, row)
                if mode_local == 'partial':
                    new_frame.paste(last_frame)
                new_frame.paste(fg, (0, 0), fg.convert('RGBA'))
                frame_holder.append(last_frame)
                nframes += 1
                last_frame = new_frame
                fg.seek(fg.tell() + 1)
        except EOFError:
            pass
        frame_holder[0].save(image,
                             save_all=True,
                             append_images=frame_holder[1:],
                             duration=duration,
                             loop=0)
        check_change_temp_final = hashlib.md5(open(image, 'rb').read()).hexdigest()
        if check_change_temp_final == check_change_temp_start:
            logf.write(image + "\n")
    else:
        for row in range(int(fg.size[1] / 16)):
            for col in range(int(fg.size[0] / 16)):
                if mode == "L":
                    fgL = fg.getpixel((col, row))
                    rb = random.getrandbits(1)
                    fgL = set_bit(fgL, rb)
                    fg.putpixel((col, row), (fgL))
                elif mode in ['RGB', 'BGR']:
                    fgr, fgg, fgb = fg.getpixel((col, row))

                    rb = random.getrandbits(1)  # create random bit
                    fgr = set_bit(fgr, rb)  # assign random bit over least important real bit

                    gb = random.getrandbits(1)
                    fgg = set_bit(fgg, gb)

                    bb = random.getrandbits(1)
                    fgb = set_bit(fgb, bb)

                    fg.putpixel((col, row), (fgr, fgg, fgb))  # add pixel with modified values to new image
                elif mode == 'RGBA':
                    rbga_bitswap(col, fg, row)
                else:
                    continue

        fg.save(image)
        check_change_temp_final = hashlib.md5(open(image, 'rb').read()).hexdigest()
        if check_change_temp_final == check_change_temp_start:
            logf.write(image + "\n")


def rbga_bitswap(col, fg, row):
    fgr, fgg, fgb, fga = fg.getpixel((col, row))
    rb = random.getrandbits(1)  # create random bit
    fgr = set_bit(fgr, rb)  # assign random bit over least important real bit
    gb = random.getrandbits(1)
    fgg = set_bit(fgg, gb)
    bb = random.getrandbits(1)
    fgb = set_bit(fgb, bb)
    fg.putpixel((col, row), (fgr, fgg, fgb, fga))


schedule.every().hour.do(pil_random)
while True:
    schedule.run_pending()
    time.sleep(60)