#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# ZetpeR xax007@yandex.ru
# Pink Panther: Passport to Peril (Розовая Пантера: Право на Риск) 
# Pink Panther: Hocus-Pocus       (Розовая Пантера: Фокус-Покус)

import os, sys, io, struct
from PIL import Image
import numpy as np

NAME = "Pink Panther" 
FORMATS_ARCHIVE = ['orb']
TYPES_ARCHIVE = [('Pink Panther', ('*.orb'))]
GAMES = ["Pink Panther: Passport to Peril",
         "Pink Panther: Hocus-Pocus"]
AUTHOR = "ZetpeR xax007@yandex.ru"

class Game_Res:
    def __init__(self,app):
        self.file = None
        self.data = [] 
        self.app = app
        
        self.sup_formats = ["cel",
                            "vox",
                            "wav",
                            "mus",
                            "txt"]

        self.sup_types = {"cel":2,
                          "vox":3,
                          "wav":3,
                          "mus":3,
                          "txt":4}
        self.images = [] 
        self.sound = None 
        self.dirname = None
        self.text = None

    def open_data(self,file):
        format = file.split(".")[-1].lower()
        if format == "orb":
            self.OpenArchiveORB(file)
    
    def unpack(self,data_res):
        self.images = []
        self.sound = None
        self.text = None
        
        name = data_res[0]
        offset = data_res[1]
        size = data_res[2]
        format = data_res[3]
        tip = data_res[4]
        self.file.seek(offset)
        if format == "cel":
            if tip == 0: 
                self.Unpack_CEL(io.BytesIO(self.file.read(size)))

            elif tip == 1: # Файлы в другом а архиве Passport to Peril
                if os.path.exists(self.dirname+"\\INSTALL\\") == False:
                    print("Ошибка нет папки с файлом INSTALL\\PPTP.BRO")
                else:
                    file2 = open(self.dirname+"\\INSTALL\\PPTP.BRO","rb")
                    file2.seek(offset)
                    self.Unpack_CEL(io.BytesIO(file2.read(size)))
        
        elif format == "wav" or format == "vox" or format == "mus":
            self.Unpack_WAV(io.BytesIO(self.file.read(size)))

        elif format == "txt":
            self.Unpack_TXT(io.BytesIO(self.file.read(size))) 
            
    def OpenArchiveORB(self,file):
        (self.dirname, filename) = os.path.split(file)
    
        data0 = [] # Список оффсетов на таблицы файлов
        f = open(file,"rb")
        
        type = f.read(4) # Тип архива ORB.
        if type != b'\x4F\x52\x42\x00':
            print("ЭТО НЕ АРХИВ",type)
            return(0)

        f.seek(6)
        type = f.read(2) # проверка на наличие таблицы файлов в архиве
        if type != b'\x02\x00':
            print("Архив без таблицы",type)
            return(0)

        f.seek(12)
        offset_lok = struct.unpack("<I",f.read(4))[0] # Оффсет на таблицы в конце файла
        col_tab = struct.unpack("<I",f.read(4))[0]    # Количество таблиц в конце файла
        f.seek(offset_lok)
    
        for i in range(col_tab): 
            filename = f.read(16)    # Имя локаци или папки
            filename = filename.split(b"\x00")[0].decode("utf8").replace("\\\\","\\")
            offset2 = struct.unpack("<I",f.read(4))[0] # Непонятный оффсет тоже ссылается на таблицу файлов но других
            size2 = struct.unpack("<I",f.read(4))[0]   # Размер для выше таблице или файла 
            offset = struct.unpack("<I",f.read(4))[0]  # Место нахождения таблиц файлов
            col_f = struct.unpack("<I",f.read(4))[0]   # Количество файлов
            data0.append((filename,offset,col_f))

        for i in data0: # Прочитать файлы
            f.seek(i[1])
            for j in range(i[2]):
                filename = f.read(16)   # Имя файла
                filename = filename.split(b"\x00")[0].decode("utf8").replace("\\\\","\\")
                format = filename.split(".")[-1].lower()
                offset = struct.unpack("<I",f.read(4))[0]  # Оффсет файла 
                size = struct.unpack("<I",f.read(4))[0]    # Размер файла
                tip = struct.unpack("<H",f.read(2))[0]     # В каком архиве находится файл
                self.data.append((i[0]+"\\"+filename,offset,size,format,tip))
        self.file = f
        return 1

    def Unpack_WAV(self, f):
        self.sound = f

    def Unpack_TXT(self, f): 
        self.text = f.read().decode("cp1251")

    def Unpack_CEL(self,f):
        pal = [] # Палитра
        f.seek(0,2)
        end_f = f.tell() # Конец файла
        f.seek(0)
        
        size_f = struct.unpack("<I",f.read(4))[0] # Размер файла
        type = f.read(2)
        if type != b'\x12\xaf':
            print("ЭТО НЕ АНИМАЦИЯ",type)
            return(0)
        framen = struct.unpack("<H",f.read(2))[0] # Количество кадров
        w,h = struct.unpack("<HH",f.read(4))      # Читаем ширину и высоту
    
        f.seek(84)
        offset_animal = struct.unpack("<I",f.read(4))[0] # Оффсет первого кадра наложения анимации
    
        f.seek(228)
        size0 = struct.unpack("<I",f.read(4))[0]-4  # Размер сжатой мини картинки
        f.read(size0)
    
        pal_size = struct.unpack("<I",f.read(4))[0] # Размер палитры + заголовок
        unclear1 = struct.unpack("<H",f.read(2))[0] # Непонятно
        unclear2 = struct.unpack("<I",f.read(4))[0] # Непонятно
        for i in range(256): # Читает палитру
            r,g,b = struct.unpack("BBB",f.read(3))
            pal.append((r,g,b,255))
    
        f2 = io.BytesIO()
        size = struct.unpack("<I",f.read(4))[0]    # Размер сжатых данных
        unclear = struct.unpack("<H",f.read(2))[0] # Непонятно
        #print("Размер сжатых данных непонятный байт",size,unclear,"Позиция",f.tell())

        for i in range(h):
            number_komand = struct.unpack("B",f.read(1))[0]
            #print("Количество команд для распаковки одной строчки",number_komand)
            sr = 0
            while True:
                if sr == w: # Остановка как только распакуется строчка в ширену
                    break
                elif sr > w:
                    print("ОШИБКА слишком много распаковалось байт",sr)
                    return(0)

                byte = struct.unpack("B",f.read(1))[0]
                if byte >> 7: # Прочитать байтов
                    byt2 = (255-byte)+1 # Сколько прочитать байтов
                    record = f.read(byt2)
                    f2.write(record)
                    #print(byte,"Прочитать байтов",byt2,record)
                    sr += byt2
                
                else: # Повторить байт
                    byt1 = f.read(1)
                    for j in range(byte):
                        f2.write(byt1)
                    #print(byte,"Повторить байт2",byt1)
                    sr += byte
        #print("Конец сжатия картинки",f.tell())
    
        f2.seek(0) 
        rgb = []
        for i in range(w*h):#
            p = struct.unpack("B",f2.read(1))[0]
            rgb.extend(pal[p])
        rgb = np.array(rgb,np.uint8).reshape(h, w, 4)
        self.images.append(Image.fromarray(rgb,"RGBA"))

        f2.seek(0) # Виртуальная картинка
    
        f.seek(offset_animal) # Переходим на начало чтения кадров наложения анимаций
        ss3 = 0 # Количество найденых анимаций наложения
    
        while True: # Цикл чтения кадров наложения анимаций
            posf0 = f.tell()
            if posf0 == end_f: # Остановка в конце файла
                break

            ss3 += 1
            size_fblock = struct.unpack("<I",f.read(4))[0] # Размер сжатых данных
            #print("Размер сжатых данных анимации",size_fblock,"Позиция заголовка",posf0)
            if size_fblock == 16: # Строчка без сжатия
                fd = f.read(12)
                #print("Строчка без сжатия",fd)

            else:     
                f.seek(posf0)
                fd = f.read(size_fblock)
                f5 = io.BytesIO(fd) # Сжатый файл
                self.Unpack_anim(w,h,f2,f5,pal,ss3) # f2 картинка в памяти, f5 сжатый файл
                f5.close()

        #print("Количество кадров",framen,"найдено",ss3)    
        f.close()
        f2.close()

    def Unpack_anim(self, w,h,picture_buffer,f,pal,ss3):
        f.seek(0,2)
        end_f = f.tell() # Конец файла
        f.seek(24)
        beginning = 0 # Начало строчки байт
        
        while True:
            if f.tell() == end_f: # Конец файла
               break
            number_blocks = struct.unpack("B",f.read(1))[0] # Количество блоков Для расчёта для одной строчке в ширину, если следующий байт 00
            unclear = struct.unpack("B",f.read(1))[0] # Проверочный байт
            if unclear == 255: # С какой строчки начать записывать данные 
                beginning += 256 - number_blocks
                #print("FF Прибавить к строчке",beginning,number_blocks,"Позиция",f.tell()-2)
                continue # Продолжить сначало цикл

            elif unclear == 254 : # b'\xFE' # На какой строчки начать записывать данные
                beginning += unclear +(255 - number_blocks)+3
                #print("FE",number_blocks,unclear,beginning,"Позиция",f.tell()-2)
                continue
            
            elif unclear == 128 : # b'\x80' # Непонятно что делать OFPPICB4 2 кадр
                #print("80 Непонятно что делать",number_blocks,unclear,"Позиция",f.tell()-2)
                continue
            
            elif unclear == 0: # Проверочный байт Значит правельно читаем блоки number_blocks
                pass
                #print("Количество блоков на строчку",number_blocks,"Позиция",f.tell()-2)

            else:
                print("Непонятное значение",unclear,"Позиция",f.tell()-2,"#########################################")
                return(0)        
            #print("С каких байт начать",beginning)
            location_line = 0 # Прибавляем к сумме начало записи на строчки
        
            for i in range(number_blocks): # Читает блоки с информацией
                checking_bytes01 = struct.unpack("B",f.read(1))[0] # Сколько отступить
                checking_bytes02 = struct.unpack("B",f.read(1))[0] # Прочитать
            
                #checking_bytes01 прибавить к данным от начало строчки чтоб узнать место записи
                location_line += checking_bytes01 # Прибавляем к сумме начало записи на строчки
                # Умножить на начало строчки в файле * ширину + байты от начало строчки 
                begtt = (beginning * w) + location_line
                picture_buffer.seek(begtt)
            
                # Сделать битовый сдвиг в право на 7, если останится 1 значит тру и заходит сюда
                if checking_bytes02 >> 7:
                    repeat = 256 - checking_bytes02  # Сколько повторить
                    data_bytes = f.read(2) # Байты повторения
                    for jjh in range(repeat):
                        picture_buffer.write(data_bytes)
                    #print("Повторить,и что",repeat,data_bytes,"Оригенальные байты",hex(checking_bytes01),hex(checking_bytes02))
                    location_line += (repeat*2) # Прибавляем записанные байты,чтоб в следующий раз правельно расчитать начало оффсета

                else: # Просто прочитать байты   самое большое число пока 4
                    read_bytes = checking_bytes02 * 2 # Узнаём сколько точно прочитать байт
                    data_bytes = f.read(read_bytes)
                    picture_buffer.write(data_bytes)
                    location_line += read_bytes # Прибавляем записанные байты,чтоб в следующий раз правельно расчитать начало оффсета
                    #print("Прочетать байты и какие",read_bytes,data_bytes,)
                    #print("Оригенальные байты",hex(checking_bytes01),hex(checking_bytes02))
                
            #print("  Новая строчка",beginning)
            beginning += 1 # Прибавить строчки Переход на новую строчку
        f.close()
    
        picture_buffer.seek(0)
        rgb = []
        for i in range(w*h):
            p = struct.unpack("B",picture_buffer.read(1))[0]
            rgb.extend(pal[p])
        rgb = np.array(rgb,np.uint8).reshape(h, w, 4)
        self.images.append(Image.fromarray(rgb,"RGBA"))
        picture_buffer.seek(0)