#!/bin/bash
set -e

# Colors
RED='\033[1;31m'
GREEN='\033[1;32m'
YELLOW='\033[1;33m'
NC='\033[0m'

# 1. Docker check (incl. Arch Linux)
if ! command -v docker &>/dev/null; then
  echo -e "${RED}❗ Docker is not installed.${NC}"
  read -p "Would you like to install Docker automatically now? [y/N]: " install_docker
  if [[ "$install_docker" =~ ^[YyJj]$ ]]; then
    if [ -f /etc/arch-release ]; then
      echo -e "${GREEN}▶️ Installing Docker for Arch Linux...${NC}"
      sudo pacman -Sy --noconfirm docker
      sudo systemctl enable --now docker.service
    else
      echo -e "${GREEN}▶️ Using generic Docker installation script...${NC}"
      curl -fsSL https://get.docker.com -o get-docker.sh
      sudo sh get-docker.sh
      rm get-docker.sh
    fi

    # Docker group membership prüfen
    if ! groups | grep -q '\bdocker\b'; then
      echo -e "${YELLOW}⚠️  Your user is not in the docker group. Adding now...${NC}"
      sudo usermod -aG docker $USER
      newgrp docker
    fi

    echo -e "${GREEN}✔️ Docker has been installed.${NC}"
  else
    echo -e "${YELLOW}❌ Docker is required. Exiting script.${NC}"
    exit 1
  fi
fi

# 2. Check Docker compose (V1 und V2 Plugin, incl. Arch Support)
DOCKER_COMPOSE_CMD=""
if command -v docker-compose &>/dev/null; then
  DOCKER_COMPOSE_CMD="docker-compose"
elif docker compose version &>/dev/null; then
  DOCKER_COMPOSE_CMD="docker compose"
else
  echo -e "${RED}❗ Neither docker-compose nor docker compose plugin is installed!${NC}"
  read -p "Would you like to install Docker Compose automatically now? [y/N]: " install_compose
  if [[ "$install_compose" =~ ^[YyJj]$ ]]; then
    if [ -f /etc/arch-release ]; then
      sudo pacman -Sy --noconfirm docker-compose
    elif command -v apt-get &>/dev/null; then
      sudo apt-get update
      sudo apt-get install -y docker-compose-plugin
      sudo apt-get install -y docker-compose
    elif command -v dnf &>/dev/null; then
      sudo dnf install -y docker-compose
    elif command -v yum &>/dev/null; then
      sudo yum install -y docker-compose-plugin
    else
      echo -e "${RED}❌ Unsupported package manager! Please install Docker Compose manually.${NC}"
      exit 1
    fi

    # Final check
    if ! command -v docker-compose &>/dev/null && ! docker compose version &>/dev/null; then
      echo -e "${RED}❌ Docker Compose installation failed!${NC}"
      exit 1
    fi
    echo -e "${GREEN}✔️ Docker Compose has been installed successfully.${NC}"
  else
    echo -e "${YELLOW}❌ Docker Compose is required. Exiting script.${NC}"
    exit 1
  fi
fi

# Configuration
PROJECT_DIR="steam-gift-manager"
TRANSLATIONS_DIR="$PWD/$PROJECT_DIR/translations"
DATA_DIR="$PWD/data"

# 1. Create folders
mkdir -p "$PROJECT_DIR"
mkdir -p "$PROJECT_DIR"/{templates,static,translations}
mkdir -p "$DATA_DIR"

chmod -R a+rwX "$TRANSLATIONS_DIR" "$DATA_DIR"

cd $PROJECT_DIR

## UID/GID-Logic
#if [ "$(id -u)" -eq 0 ]; then
#  export UID=1000
#  export GID=1000
#else
#  export UID=$(id -u)
#  export GID=$(id -g)
#fi

# 2. requirements.txt
cat <<EOL > requirements.txt
flask
flask-login
flask-wtf
flask-migrate
werkzeug
python-dotenv
flask-sqlalchemy
jinja2<3.1.0
itsdangerous
sqlalchemy
apscheduler
reportlab
requests
pillow
gunicorn
apprise
debugpy
pytz
Flask-Session
redis
EOL


# 3. create .env
SECRET_KEY=$(python3 -c 'import secrets; print(secrets.token_hex(24))')
REDEEM_SECRET=$(python3 -c 'import secrets; print(secrets.token_hex(16))')
REDEEM_CSRF=$(python3 -c 'import secrets; print(secrets.token_hex(16))')

cat <<EOL > .env
# Flask-Configuration
SECRET_KEY="$SECRET_KEY"
REDEEM_SECRET="$REDEEM_SECRET"
WTF_CSRF_SECRET_KEY="$REDEEM_CSRF"

# Language Settings
DEFAULT_LANGUAGE="en"
SUPPORTED_LANGUAGES="de,en"

# Timezone
TZ=Europe/Berlin

# Security
FORCE_HTTPS=False
SESSION_COOKIE_SECURE=auto
CSRF_ENABLED="True"
# Account registration
REGISTRATION_ENABLED="True"

# checking interval if keys have to be redeemed before a specific date
CHECK_EXPIRING_KEYS_INTERVAL_HOURS=6

# Want to check prices? Here you are!
ITAD_API_KEY="your-secret-key-here"
ITAD_COUNTRY="DE"

# Apprise URLs (separate several with a line break, comma or space)
APPRISE_URLS=""

### example for multiple notifications
#APPRISE_URLS="pover://USER_KEY@APP_TOKEN
#gotify://gotify.example.com/TOKEN
#matrixs://TOKEN@matrix.org/!ROOM_ID"

# Redis URL
REDIS_URL=redis://redis:6379/0

# Enable Debug (e.g. for VS Code)
FLASK_DEBUG=1
DEBUGPY=1
EOL

# 4. app.py (the main app)
cat <<'PYTHON_END' > app.py
import os, time
from datetime import datetime, timedelta
from zoneinfo import ZoneInfo
import pytz
import warnings
from sqlalchemy.exc import LegacyAPIWarning
warnings.simplefilter("ignore", category=LegacyAPIWarning)
from flask import (
    Flask,
    render_template,
    request,
    redirect,
    url_for,
    flash,
    session,
    abort,
    send_file,
    jsonify,
    Markup,
    make_response,
    g,
    abort
)
from flask_sqlalchemy import SQLAlchemy
from flask_session import Session
from flask_login import LoginManager, UserMixin, login_user, logout_user, login_required, current_user
from werkzeug.security import generate_password_hash, check_password_hash
from flask_wtf import CSRFProtect
from flask import abort
from flask import request, redirect
from flask_wtf import FlaskForm
from flask_wtf.csrf import CSRFProtect
from wtforms import StringField, SelectField, TextAreaField, validators
import io
import warnings
import re
import io
import csv
import secrets
import requests
from dotenv import load_dotenv
load_dotenv(override=True)
from sqlalchemy.exc import IntegrityError
from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
import atexit
from flask_migrate import Migrate
from sqlalchemy import MetaData, event, UniqueConstraint
from reportlab.pdfgen import canvas
from reportlab.lib.pagesizes import A4, landscape, letter
from reportlab.platypus import (
    SimpleDocTemplate, 
    Table, 
    TableStyle, 
    Paragraph, 
    Image, 
    Spacer
)
from reportlab.lib import colors
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
from reportlab.lib.utils import ImageReader
from reportlab.lib.units import cm, inch, mm
from io import BytesIO
import reportlab.lib
import traceback
import logging
logging.basicConfig(level=logging.INFO)
# logging.basicConfig(level=logging.INFO)
logging.getLogger('apscheduler').setLevel(logging.WARNING)
from sqlalchemy.engine import Engine
import sqlite3
from sqlalchemy.orm import joinedload
from functools import wraps
from flask_session import Session
from redis import Redis
from time import sleep
import random
import locale

@event.listens_for(Engine, "connect")
def enable_foreign_keys(dbapi_connection, connection_record):
    if isinstance(dbapi_connection, sqlite3.Connection):
        cursor = dbapi_connection.cursor()
        cursor.execute("PRAGMA foreign_keys=ON;")
        cursor.close()

TZ = os.getenv('TZ', 'UTC')
os.environ['TZ'] = TZ
app = Flask(__name__)

# Auf UNIX-Systemen (Linux, Docker) wirksam machen
try:
    time.tzset()
except AttributeError:
    pass  # tzset gibt es auf Windows nicht
local_tz = pytz.timezone(TZ)

# Load Languages
import os
import json


TRANSLATION_DIR = os.path.join(os.getcwd(), 'translations')
SUPPORTED_LANGUAGES = ['de', 'en']
TRANSLATIONS = {}

for lang in SUPPORTED_LANGUAGES:
    try:
        with open(os.path.join(TRANSLATION_DIR, f'{lang}.json'), encoding='utf-8') as f:
            TRANSLATIONS[lang] = json.load(f)
        print(f"✅ Loaded {lang} translations")
    except Exception:
        print(f"❌ Failed loading {lang}.json: {str(e)}")
        TRANSLATIONS[lang] = {}

def translate(key, lang=None, **kwargs):
    lang = lang or session.get('lang', 'en')
    fallback_lang = app.config.get('DEFAULT_LANGUAGE', 'en')
    
    translations = TRANSLATIONS.get(lang, {})
    fallback_translations = TRANSLATIONS.get(fallback_lang, {})
    
    value = translations.get(key) or fallback_translations.get(key) or key
    return value.format(**kwargs) if isinstance(value, str) else value

## DEBUG Translations
if app.debug:
    print(f"Loaded translations for 'de': {TRANSLATIONS.get('de', {})}")

### Admin decorator
def admin_required(f):
    @wraps(f)
    def decorated_function(*args, **kwargs):
        if not current_user.is_authenticated:
            abort(403)
        if not current_user.is_admin:
            abort(403)
        return f(*args, **kwargs)
    return decorated_function


csrf = CSRFProtect(app)

convention = {
    "ix": "ix_%(column_0_label)s",
    "uq": "uq_%(table_name)s_%(column_0_name)s",
    "ck": "ck_%(table_name)s_%(constraint_name)s",
    "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
    "pk": "pk_%(table_name)s"
}

metadata = MetaData(naming_convention=convention)
load_dotenv(override=True)

# Lade Umgebungsvariablen aus .env mit override
load_dotenv(override=True)

# App-Configuration
app.config.update(
    # WICHTIGSTE EINSTELLUNGEN
    SECRET_KEY=os.getenv('SECRET_KEY'),
    SQLALCHEMY_DATABASE_URI = 'sqlite:////app/data/games.db',
    SQLALCHEMY_TRACK_MODIFICATIONS = False,
    DEFAULT_LANGUAGE='en',
    ITAD_COUNTRY = os.getenv("ITAD_COUNTRY", "DE"),

    # SESSION-HANDLING (Produktion: Redis verwenden!)
    SESSION_TYPE='redis',
    SESSION_PERMANENT = False,
    SESSION_USE_SIGNER = True,
    SESSION_REDIS=Redis.from_url(os.getenv("REDIS_URL", "redis://redis:6379/0")),
    SESSION_FILE_DIR = '/app/data/flask-sessions',
    SESSION_COOKIE_NAME = 'gamekeys_session',
    SESSION_COOKIE_SECURE = os.getenv('SESSION_COOKIE_SECURE', 'False').lower() == 'true',
    SESSION_COOKIE_HTTPONLY = True,
    SESSION_COOKIE_SAMESITE = 'Lax',
    PERMANENT_SESSION_LIFETIME = timedelta(days=30),

    # CSRF-PROTECTION
    WTF_CSRF_ENABLED = True,
    WTF_CSRF_SECRET_KEY = os.getenv('CSRF_SECRET_KEY', os.urandom(32).hex()),
    WTF_CSRF_TIME_LIMIT = 3600,

    # SECURITYsa & PERFORMANCE
    REGISTRATION_ENABLED = os.getenv('REGISTRATION_ENABLED', 'True').lower() == 'true',
    SEND_FILE_MAX_AGE_DEFAULT = int(os.getenv('SEND_FILE_MAX_AGE_DEFAULT', 0)),
    TEMPLATES_AUTO_RELOAD = os.getenv('TEMPLATES_AUTO_RELOAD', 'True').lower() == 'true',
    PREFERRED_URL_SCHEME = 'https' if os.getenv('FORCE_HTTPS') else 'http'
)


Session(app)

interval_hours = int(os.getenv('CHECK_EXPIRING_KEYS_INTERVAL_HOURS', 12))

# Initialisation
db = SQLAlchemy(app, metadata=metadata)
migrate = Migrate(app, db)
login_manager = LoginManager(app)
login_manager.login_view = 'login'

# Logging
app.logger.addHandler(logging.StreamHandler())
app.logger.setLevel(logging.DEBUG)


@app.before_request
def set_language():
    if 'lang' not in session or not session['lang']:
        session['lang'] = app.config.get('DEFAULT_LANGUAGE', 'en')
    g.lang = session['lang']

def enforce_https():
    if os.getenv('FORCE_HTTPS', 'False').lower() == 'true' and not app.debug:
        proto = request.headers.get('X-Forwarded-Proto', 'http')
        if proto != 'https' and not request.is_secure:
            url = request.url.replace('http://', 'https://', 1)
            return redirect(url, code=301)

def debug_translations():
    if app.debug:
        app.logger.debug(f"Lang: {session.get('lang')}")

app.before_request(enforce_https)



@app.context_processor
def inject_template_globals():
    return {
        '_': lambda key, **kwargs: translate(key, lang=session.get('lang', 'en'), **kwargs),
        'now': datetime.now(local_tz),
        'app_version': os.getenv('APP_VERSION', '1.0.0'),
        'local_tz': local_tz
    }

@app.template_filter('strftime')
def _jinja2_filter_datetime(date, fmt='%d.%m.%Y'):
    if date is None:
        return ''
    return date.strftime(fmt)

@app.errorhandler(403)
def forbidden(e):
    return render_template('403.html'), 403


# DB Models
class ActivityLog(db.Model):
    __tablename__ = 'activity_logs'
    
    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
    action = db.Column(db.String(100), nullable=False)
    details = db.Column(db.Text)
    timestamp = db.Column(db.DateTime, default=lambda: datetime.now(local_tz))
    
    user = db.relationship('User', backref='activities')


class User(UserMixin, db.Model):
    __tablename__ = 'users'
    
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    password = db.Column(db.String(256), nullable=False)
    is_admin = db.Column(db.Boolean, default=False)
    games = db.relationship(
        'Game', 
        back_populates='owner', 
        cascade='all, delete-orphan',
        passive_deletes=True
    )


class Game(db.Model):
    __tablename__ = 'games'
    __table_args__ = (
        UniqueConstraint('steam_key', 'user_id', name='uq_steam_key_user'),
    )
    
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100), nullable=False)
    steam_key = db.Column(db.String(100), nullable=False, unique=True)
    status = db.Column(db.String(50), nullable=False)
    recipient = db.Column(db.String(100))
    notes = db.Column(db.Text)
    url = db.Column(db.String(200))
    created_at = db.Column(db.DateTime, default=lambda: datetime.now(local_tz))
    redeem_date = db.Column(db.DateTime)
    steam_appid = db.Column(db.String(20))
    platform = db.Column(db.String(50), default='pc')
    current_price = db.Column(db.Float)
    historical_low = db.Column(db.Float)
    release_date = db.Column(db.DateTime)
    metacritic_score = db.Column(db.Integer)
    release_date = db.Column(db.DateTime)
    steam_description = db.Column(db.Text)
    itad_slug = db.Column(db.String(200))

    
    # with users.id
    user_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete='CASCADE'), nullable=False)
    
    owner = db.relationship(
        'User', 
        back_populates='games'
    )
    
    redeem_tokens = db.relationship(
        'RedeemToken',
        back_populates='game',
        cascade='all, delete-orphan',
        passive_deletes=True
    )

class RedeemToken(db.Model):
    __tablename__ = 'redeem_tokens'
    
    id = db.Column(db.Integer, primary_key=True)
    token = db.Column(db.String(17), unique=True, nullable=False)
    expires = db.Column(db.DateTime(timezone=True), nullable=False)
    total_hours = db.Column(db.Integer, nullable=False)
    
    # ForeignKey with CASCADE
    game_id = db.Column(
        db.Integer, 
        db.ForeignKey('games.id', ondelete='CASCADE'),
        nullable=False
    )
    
    game = db.relationship('Game', back_populates='redeem_tokens')

    def is_expired(self):
        # use timeszone (from .env)
        local_tz = pytz.timezone(os.getenv('TZ', 'UTC'))
        now = datetime.now(local_tz)
        return now > self.expires.astimezone(local_tz)


class GameForm(FlaskForm):
    name = StringField('Name', [validators.DataRequired()])
    steam_key = StringField('Steam Key')
    status = SelectField('Status', choices=[
        ('nicht eingelöst', 'Nicht eingelöst'),
        ('eingelöst', 'Eingelöst'),
        ('geschenkt', 'Geschenkt')
    ])
    recipient = StringField('Empfänger')
    notes = TextAreaField('Notizen')
    url = StringField('Store URL')
    redeem_date = StringField('Einlösedatum')
    steam_appid = StringField('Steam App ID')
    

PLATFORM_CHOICES = [
    ('pc', 'PC'),
    ('xbox', 'XBox'),
    ('playstation', 'PlayStation'),
    ('switch', 'Nintendo Switch'),
    ('other', 'Andere')
]

STATUS_CHOICES = [
    ('nicht eingelöst', 'Nicht eingelöst'),
    ('eingelöst', 'Eingelöst'),
    ('geschenkt', 'Geschenkt')
]


with app.app_context():
    db.create_all()

@login_manager.user_loader
def load_user(user_id):
    return db.session.get(User, int(user_id))

def extract_steam_appid(url):
    match = re.search(r'store\.steampowered\.com/app/(\d+)', url or '')
    return match.group(1) if match else ''

# 404 
def get_or_404(model, id):
    instance = db.session.get(model, id)
    if not instance:
        abort(404)
    return instance

# Admin Audit Helper
def log_activity(user_id, action, details=None):
    """
    Store an activity log entry for auditing purposes.
    """
    log = ActivityLog(
        user_id=user_id,
        action=action,
        details=details
    )
    db.session.add(log)
    db.session.commit()

# Game Infos Helper
def fetch_steam_data(appid):
    try:
        response = requests.get(
            "https://store.steampowered.com/api/appdetails",
            params={"appids": appid, "l": "german"},
            timeout=15
        )
        if response.status_code != 200:
            app.logger.error(f"Steam API Error: Status {response.status_code}")
            return None
            
        data = response.json().get(str(appid), {})
        if not data.get("success"):
            app.logger.error(f"Steam API Error: {data.get('error', 'Unknown error')}")
            return None
            
        return data.get("data", {})
    except Exception as e:
        app.logger.error(f"Steam API Exception: {str(e)}")
        return None

def parse_steam_release_date(date_str):
    """Parst Steam-Release-Daten im deutschen oder englischen Format."""
    import locale
    from datetime import datetime

    # Versuche deutsches Format
    try:
        locale.setlocale(locale.LC_TIME, "de_DE.UTF-8")
        return datetime.strptime(date_str, "%d. %b. %Y")
    except Exception:
        pass
    # Fallback: Versuche englisches Format
    try:
        locale.setlocale(locale.LC_TIME, "en_US.UTF-8")
        return datetime.strptime(date_str, "%d %b, %Y")
    except Exception:
        pass
    return None

def fetch_itad_slug(steam_appid: int) -> str | None:
    api_key = os.getenv("ITAD_API_KEY")
    if not api_key:
        return None
    try:
        response = requests.get(
            "https://api.isthereanydeal.com/games/lookup/v1",
            params={"key": api_key, "appid": steam_appid, "platform": "steam"},
            timeout=10
        )
        data = response.json()
        return data.get("game", {}).get("slug")
    except Exception as e:
        app.logger.error(f"ITAD Error: {str(e)}")
        return None



def fetch_itad_game_id(steam_appid: int) -> str | None:
    api_key = os.getenv("ITAD_API_KEY")
    if not api_key:
        app.logger.error("ITAD_API_KEY nicht gesetzt")
        return None

    try:
        response = requests.get(
            "https://api.isthereanydeal.com/games/lookup/v1",
            params={"key": api_key, "appid": steam_appid, "platform": "steam"},
            timeout=10
        )
        response.raise_for_status()
        data = response.json()
        if data.get("found") and data.get("game") and data["game"].get("id"):
            return data["game"]["id"]
        app.logger.error(f"ITAD Response Error: {data}")
        return None
    except Exception as e:
        app.logger.error(f"ITAD Error: {str(e)}")
        return None


def fetch_itad_prices(game_id: str) -> dict | None:
    api_key = os.getenv("ITAD_API_KEY")
    country = os.getenv("ITAD_COUNTRY", "DE")
    if not api_key:
        return None

    try:
        response = requests.post(
            "https://api.isthereanydeal.com/games/prices/v3",
            params={
                "key": api_key,
                "country": country,
                "shops": "steam",
                "vouchers": "false"
            },
            json=[game_id],
            headers={"Content-Type": "application/json"},
            timeout=15
        )
        response.raise_for_status()
        return response.json()[0]
    
    except Exception as e:
        app.logger.error(f"ITAD-Preisabfrage fehlgeschlagen: {str(e)}")
        return None


@app.route('/')
@login_required
def index():
    search_query = request.args.get('q', '')
    query = Game.query.filter_by(user_id=current_user.id)
    
    if search_query:
        query = query.filter(Game.name.ilike(f'%{search_query}%'))
    
    games = query.order_by(Game.created_at.desc()).all()
    return render_template('index.html',
                         games=games,
                         format_date=lambda dt: dt.strftime('%d.%m.%Y') if dt else '',
                         search_query=search_query)

@app.route('/set-lang/<lang>')
def set_lang(lang):
    if lang in SUPPORTED_LANGUAGES:
        session['lang'] = lang
        session.permanent = True
    return redirect(request.referrer or url_for('index'))
    
@app.route('/set-theme/<theme>')
def set_theme(theme):
    resp = make_response('', 204)
    resp.set_cookie('theme', theme, max_age=60*60*24*365)  # 1 Jahr Gültigkeit
    return resp

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        username = request.form['username']
        password = request.form['password']
        user = User.query.filter_by(username=username).first()
        
        if user and check_password_hash(user.password, password):
            login_user(user)
            return redirect(url_for('index'))
        
        flash(translate('Invalid credentials', session.get('lang', 'en')), 'danger')
    return render_template('login.html')

@app.route('/register', methods=['GET', 'POST'])
def register():
    if not app.config['REGISTRATION_ENABLED']:
        abort(403)

    if request.method == 'POST':
        username = request.form['username']
        password = request.form['password']

        existing_user = User.query.filter_by(username=username).first()
        if existing_user:
            flash(translate('Username already exists'), 'error')
            return redirect(url_for('register'))

        # make the first user admin
        is_admin = User.query.count() == 0

        new_user = User(
            username=username,
            password=generate_password_hash(password),
            is_admin=is_admin
        )

        db.session.add(new_user)
        db.session.commit()
        login_user(new_user)
        flash(translate('Registration successful'), 'success')
        return redirect(url_for('index'))

    return render_template('register.html')

@app.route('/logout')
@login_required
def logout():
    logout_user()
    return redirect(url_for('login'))

@app.route('/change-password', methods=['GET', 'POST'])
@login_required
def change_password():
    if request.method == 'POST':
        current_password = request.form['current_password']
        new_password = request.form['new_password']
        confirm_password = request.form['confirm_password']

        if not check_password_hash(current_user.password, current_password):
            flash(translate('Current passwort is wrong'), 'danger')
            return redirect(url_for('change_password'))

        if new_password != confirm_password:
            flash(translate('New Passwords are not matching'), 'danger')
            return redirect(url_for('change_password'))

        current_user.password = generate_password_hash(new_password)
        db.session.commit()
        flash(translate('Password changed successfully', session.get('lang', 'en')), 'success')
        return redirect(url_for('index'))

    return render_template('change_password.html')

@app.route('/add', methods=['GET', 'POST'])
@login_required
def add_game():
    if request.method == 'POST':
        try:
            url = request.form.get('url', '')
            steam_appid = request.form.get('steam_appid', '').strip()
            
            if not steam_appid:
                steam_appid = extract_steam_appid(url)

            steam_key = request.form['steam_key']
            if Game.query.filter_by(steam_key=steam_key).first():
                flash(translate('Steam Key already exists!'), 'error')
                return redirect(url_for('add_game'))

            new_game = Game(
                name=request.form['name'],
                steam_key=steam_key,
                status=request.form['status'],
                recipient=request.form.get('recipient', ''),
                notes=request.form.get('notes', ''),
                url=url,
                steam_appid=steam_appid,
                redeem_date=datetime.strptime(request.form['redeem_date'], '%Y-%m-%d') if request.form['redeem_date'] else None,
                user_id=current_user.id
            )
            
            db.session.add(new_game)
            db.session.commit()
            flash(translate('Game added successfully!'), 'success')
            return redirect(url_for('index'))
        
        except IntegrityError as e:
            db.session.rollback()
            if "UNIQUE constraint failed: game.steam_key" in str(e):
                flash(translate('Steam Key already exists!'), 'error')
            else:
                flash(translate('Database error: %(error)s', error=str(e)), 'error')
        
        except Exception as e:
            db.session.rollback()
            flash(translate('Error: %(error)s', error=str(e)), 'error')
    
    return render_template(
        'add_game.html',
        platforms=PLATFORM_CHOICES,
        statuses=STATUS_CHOICES
    )


@app.route('/edit/<int:game_id>', methods=['GET', 'POST'])
@login_required
def edit_game(game_id):
    # Eager Loading für Tokens
    game = Game.query.options(joinedload(Game.redeem_tokens)).get_or_404(game_id)

    def safe_parse_date(date_str):
        try:
            naive = datetime.strptime(date_str, '%Y-%m-%d') if date_str else None
            return local_tz.localize(naive) if naive else None
        except ValueError:
            return None

    if request.method == 'POST':
        try:
            # Validierung
            if not request.form.get('name') or not request.form.get('steam_key'):
                flash(translate('Name and Steam Key are required'), 'error')
                return redirect(url_for('edit_game', game_id=game_id))

            # Dublettenprüfung
            existing = Game.query.filter(
                Game.steam_key == request.form['steam_key'],
                Game.id != game.id,
                Game.user_id == current_user.id 
            ).first()
            if existing:
                flash(translate('Steam Key already exists'), 'error')
                return redirect(url_for('edit_game', game_id=game_id))

            # Felder aktualisieren
            game.name = request.form['name']
            game.steam_key = request.form['steam_key']
            game.status = request.form['status']
            game.platform = request.form.get('platform', 'pc')
            game.recipient = request.form.get('recipient', '')
            game.notes = request.form.get('notes', '')
            game.url = request.form.get('url', '')
            game.steam_appid = request.form.get('steam_appid', '')
            game.redeem_date = safe_parse_date(request.form.get('redeem_date', ''))
            
            # Zeitzonen-korrekte Umwandlung
            game.redeem_date_local = (
                game.redeem_date.astimezone(local_tz) 
                if game.redeem_date 
                else None
            )

            # Token-Logik
            if game.status == 'geschenkt':
                # Vorhandene Tokens löschen
                RedeemToken.query.filter_by(game_id=game.id).delete()
                
                # Neuen Token generieren
                token = secrets.token_urlsafe(12)[:17]
                expires = datetime.now(local_tz) + timedelta(hours=24)
                new_token = RedeemToken(
                    token=token,
                    game_id=game.id,
                    expires=expires,
                    total_hours=24
                )
                db.session.add(new_token)

            db.session.commit()
            flash(translate('Changes saved successfully'), 'success')
            return redirect(url_for('index'))

        except IntegrityError as e:
            db.session.rollback()
            app.logger.error(f"IntegrityError: {traceback.format_exc()}")
            flash(translate('Database error: {error}', error=str(e.orig)), 'error')  # Platzhalter korrigiert
        except Exception as e:
            db.session.rollback()
            app.logger.error(f"Unexpected error: {traceback.format_exc()}")
            flash(translate('Unexpected error: {error}', error=str(e)), 'error')  # Platzhalter korrigiert

    return render_template(
        'edit_game.html',
        game=game,
        platforms=PLATFORM_CHOICES,
        statuses=STATUS_CHOICES,
        redeem_date=game.redeem_date.strftime('%Y-%m-%d') if game.redeem_date else ''
    )


@app.route('/delete/<int:game_id>', methods=['POST'])
@login_required
def delete_game(game_id):
    game = Game.query.get_or_404(game_id)
    db.session.delete(game)
    db.session.commit()
    flash(translate('Game deleted successfully'), 'success')
    return redirect(url_for('index'))


@app.route('/export', methods=['GET'])
@login_required
def export_games():
    games = Game.query.filter_by(user_id=current_user.id).all()
    output = io.StringIO()
    writer = csv.writer(output)
    
    writer.writerow(['Name', 'Steam Key', 'Status', 'Recipient', 'Notes', 'URL', 'Created', 'Redeem by', 'Steam AppID'])
    
    for game in games:
        writer.writerow([
            game.name, 
            game.steam_key, 
            game.status, 
            game.recipient, 
            game.notes,
            game.url, 
            game.created_at.strftime('%Y-%m-%d %H:%M:%S') if game.created_at else '',
            game.redeem_date.strftime('%Y-%m-%d') if game.redeem_date else '',
            game.steam_appid
        ])
    
    output.seek(0)
    return send_file(
        io.BytesIO(output.getvalue().encode('utf-8')),
        mimetype='text/csv',
        as_attachment=True,
        download_name='games_export.csv'
    )


@app.route('/export_pdf')
@login_required
def export_pdf():
    excluded_statuses = ['eingelöst', 'verschenkt']
    
    games = Game.query.filter(
        Game.user_id == current_user.id,
        Game.status.notin_(excluded_statuses)
    ).order_by(Game.created_at.desc()).all()

    buffer = io.BytesIO()
    doc = SimpleDocTemplate(buffer, 
        pagesize=landscape(A4),
        leftMargin=40,
        rightMargin=40,
        topMargin=40,
        bottomMargin=40
    )
    
    styles = getSampleStyleSheet()
    elements = []
    img_height = 2*cm

    # Titel
    elements.append(Paragraph(
        translate("Game List (without Keys)", lang=session.get('lang', 'en')), 
        styles['Title']
    ))
    elements.append(Spacer(1, 12))

    # Tabellenkopf
    col_widths = [
        5*cm, 10*cm, 6*cm, 3*cm
    ]
    data = [[
        Paragraph('<b>Cover</b>', styles['Normal']),
        Paragraph('<b>Name</b>', styles['Normal']),
        Paragraph('<b>Shop-Link</b>', styles['Normal']),
        Paragraph('<b>Einlösen bis</b>', styles['Normal'])
    ]]

    for game in games:
        img = None
        if game.steam_appid:
            try:
                img_url = f"https://cdn.cloudflare.steamstatic.com/steam/apps/{game.steam_appid}/header.jpg"
                img_data = io.BytesIO(requests.get(img_url, timeout=5).content)
                img = Image(img_data, width=3*cm, height=img_height)
            except Exception:
                img = Paragraph('', styles['Normal'])
        elif game.url and 'gog.com' in game.url:
            try:
                img_path = os.path.join(app.root_path, 'static', 'gog_logo.webp')
                img = Image(img_path, width=3*cm, height=img_height)
            except Exception:
                img = Paragraph('', styles['Normal'])
        
        data.append([
            img or '',
            Paragraph(game.name, styles['Normal']),
            Paragraph(game.url or '', styles['Normal']),
            game.redeem_date.strftime('%d.%m.%y') if game.redeem_date else ''
        ])

    # Table format (korrekte Einrückung)
    table = Table(data, colWidths=col_widths, repeatRows=1)
    table.setStyle(TableStyle([
        ('FONTNAME', (0,0), (-1,0), 'Helvetica-Bold'),
        ('FONTSIZE', (0,0), (-1,0), 8),
        ('FONTSIZE', (0,1), (-1,-1), 8),
        ('VALIGN', (0,0), (-1,-1), 'MIDDLE'),
        ('ALIGN', (0,0), (-1,-1), 'LEFT'),
        ('GRID', (0,0), (-1,-1), 0.5, colors.lightgrey),
        ('WORDWRAP', (1,1), (1,-1), 'CJK'),
    ]))
    
    elements.append(table)
    doc.build(elements)

    buffer.seek(0)
    return send_file( 
        buffer,
        mimetype='application/pdf',
        as_attachment=True,
        download_name=f'game_export_{datetime.now().strftime("%Y%m%d")}.pdf'
    )


@app.route('/import', methods=['GET', 'POST'])
@login_required
def import_games():
    if request.method == 'POST':
        file = request.files.get('file')
        
        if file and file.filename.endswith('.csv'):
            stream = io.StringIO(file.stream.read().decode("UTF8"))
            reader = csv.DictReader(stream)
            new_games = 0
            duplicates = 0
            
            try:
                with db.session.begin_nested():
                    for row in reader:
                        steam_key = row['Steam Key'].strip()
                        
                        if Game.query.filter_by(steam_key=steam_key).first():
                            duplicates += 1
                            continue
                        
                        game = Game(
                            name=row['Name'],
                            steam_key=steam_key,
                            status=row['Status'],
                            recipient=row.get('Recipient', ''),
                            notes=row.get('Notes', ''),
                            url=row.get('URL', ''),
                            created_at=datetime.strptime(row['Created'], '%Y-%m-%d %H:%M:%S') if row.get('Created') else datetime.utcnow(),
                            redeem_date=datetime.strptime(row['Redeem by'], '%Y-%m-%d') if row.get('Redeem by') else None,
                            steam_appid=row.get('Steam AppID', ''),
                            user_id=current_user.id
                        )
                        
                        db.session.add(game)
                        new_games += 1
                    
                    db.session.commit()
                
                flash(translate("new_games_imported", new=new_games, dup=duplicates), 'success')
            
            except Exception as e:
                db.session.rollback()
                flash(translate('Import error: {error}', error=str(e)), 'danger')
            
            return redirect(url_for('index'))
        
        flash(translate('Please upload a valid CSV file.'), 'danger')
    
    return render_template('import.html')


@app.route('/generate_redeem/<int:game_id>', methods=['POST'])
@login_required
def generate_redeem(game_id):
    game = Game.query.get_or_404(game_id)
    if game.user_id != current_user.id or game.status != 'geschenkt':
        return jsonify({'error': translate('Forbidden')}), 403

    try:
        RedeemToken.query.filter_by(game_id=game_id).delete()
        token = secrets.token_urlsafe(12)[:17]
        expires = datetime.now(local_tz) + timedelta(hours=24)
        new_token = RedeemToken(
            token=token,
            game_id=game_id,
            expires=expires,
            total_hours=24
        )
        db.session.add(new_token)
        db.session.commit()
        redeem_url = url_for('redeem', token=token, _external=True)
        message = translate(
            'Redeem link generated: <a href="{url}" target="_blank">{url}</a>',
            url=redeem_url
        )
        return jsonify({'url': redeem_url, 'message': message})
    except Exception as e:
        db.session.rollback()
        return jsonify({'error': str(e)}), 500


@app.route('/redeem/<token>', endpoint='redeem')
def redeem_page(token):
    redeem_token = RedeemToken.query.filter_by(token=token).first()
    
    if not redeem_token:
        abort(404)
    
    # Zeit in UTC umwandeln
    expires_utc = redeem_token.expires.astimezone(pytz.UTC)
    
    if datetime.now(pytz.UTC) > expires_utc:
        db.session.delete(redeem_token)
        db.session.commit()
        abort(404)
    
    game = Game.query.get(redeem_token.game_id)
    redeem_token.used = True
    db.session.commit()

    return render_template('redeem.html',
                         game=game,
                         redeem_token=redeem_token,
                         expires_timestamp=int(expires_utc.timestamp() * 1000),  # Millisekunden
                         platform_link='https://store.steampowered.com/account/registerkey?key=' if game.steam_appid else 'https://www.gog.com/redeem')

@app.route('/admin/users')
@login_required
@admin_required
def admin_users():
    users = User.query.all()
    return render_template('admin_users.html', users=users)

@app.route('/admin/users/delete/<int:user_id>', methods=['POST'])
@login_required
@admin_required
def admin_delete_user(user_id):
    if current_user.id == user_id:
        flash(translate('You cannot delete yourself'), 'error')
        return redirect(url_for('admin_users'))
    
    user = User.query.get_or_404(user_id)
    db.session.delete(user)
    db.session.commit()
    
    log_activity(
        current_user.id,
        'user_deleted',
        f"Deleted user: {user.username} (ID: {user.id})"
    )
    
    flash(translate('User deleted successfully'), 'success')
    return redirect(url_for('admin_users'))

@app.route('/admin/users/reset_password/<int:user_id>', methods=['POST'])
@login_required
@admin_required
def admin_reset_password(user_id):
    user = User.query.get_or_404(user_id)
    new_password = secrets.token_urlsafe(8)
    user.password = generate_password_hash(new_password)
    db.session.commit()
    
    log_activity(
        current_user.id,
        'user_newpassword',
        f"New password for user: {user.username} (ID: {user.id})"
    )
    

    flash(
        translate('New password for {username}: {password}', 
                  username=user.username, 
                  password=new_password),
        'info'
    )
    return redirect(url_for('admin_users'))

@app.route('/admin/audit-logs')
@login_required
@admin_required
def admin_audit_logs():
    page = request.args.get('page', 1, type=int)
    logs = ActivityLog.query.order_by(ActivityLog.timestamp.desc()).paginate(page=page, per_page=20)
    return render_template('admin_audit_logs.html', logs=logs)

@app.route('/game/<int:game_id>/update', methods=['POST'])
@login_required
def update_game_data(game_id):
    game = Game.query.get_or_404(game_id)
    
    # 1. Steam AppID aus dem Formular holen
    steam_appid = request.form.get('steam_appid', '').strip()
    app.logger.info(f"🚀 Update gestartet für Game {game_id} mit AppID: {steam_appid}")

    # 2. Steam-Daten abrufen
    steam_data = None
    if steam_appid:
        try:
            app.logger.debug(f"🔍 Steam-API-Aufruf für AppID: {steam_appid}")
            steam_data = fetch_steam_data(steam_appid)
            
            if steam_data:
                # 3. Daten in Datenbank schreiben
                game.name = steam_data.get("name", game.name)
                game.steam_description = steam_data.get("detailed_description") or "No Infos available"
                
                # Release-Datum mit Zeitzone
                date_str = steam_data.get("release_date", {}).get("date")
                if date_str:
                    parsed_date = parse_steam_release_date(date_str)
                    if parsed_date:
                        game.release_date = local_tz.localize(parsed_date)
                    else:
                        app.logger.warning(f"Could not parse Steam release date: {date_str}")
                
                app.logger.info("✅ Steam-Daten erfolgreich aktualisiert")
            else:
                app.logger.warning("⚠️ Keine Steam-Daten empfangen")
                flash(translate('Steam-API lieferte keine Daten'), 'warning')
                
        except Exception as e:
            app.logger.error(f"💥 Kritischer Steam-Fehler: {str(e)}", exc_info=True)
            flash(translate('Fehler bei Steam-Abfrage'), 'danger')

    # ITAD-Slug abrufen und speichern
    itad_slug = fetch_itad_slug(steam_appid)
    if itad_slug:
        game.itad_slug = itad_slug

    # 4. ITAD-Preisdaten
    price_data = None
    if steam_appid:
        try:
            app.logger.debug("🔄 Starte ITAD-Abfrage...")
            game.itad_game_id = fetch_itad_game_id(steam_appid)
            
            if game.itad_game_id:
                app.logger.info(f"🔑 ITAD Game ID: {game.itad_game_id}")
                price_data = fetch_itad_prices(game.itad_game_id)
                
                if price_data:
                    # Aktueller Steam-Preis
                    steam_deal = next(
                        (deal for deal in price_data.get("deals", []) 
                         if deal.get("shop", {}).get("name", "").lower() == "steam"),
                        None
                    )
                    
                    if steam_deal:
                        game.current_price = steam_deal.get("price", {}).get("amount")
                        app.logger.info(f"💶 Aktueller Preis: {game.current_price}€")
                    
                    # Historisches Minimum
                    game.historical_low = price_data.get("historyLow", {}).get("all", {}).get("amount")
                    app.logger.info(f"📉 Historisches Minimum: {game.historical_low}€")
                else:
                    app.logger.warning("⚠️ Keine ITAD-Preisdaten erhalten")
            else:
                app.logger.warning("⚠️ Keine ITAD Game ID erhalten")
                
        except Exception as e:
            app.logger.error(f"💥 ITAD-API-Fehler: {str(e)}", exc_info=True)
            flash(translate('Fehler bei Preisabfrage'), 'danger')

    # 5. Metacritic-Score (Beispielimplementierung)
    try:
        if game.name:
            app.logger.info(f"🎮 Starte Metacritic-Abfrage für: {game.name}")
            # Hier echte API-Integration einfügen
            game.metacritic_score = random.randint(50, 100)  # Mock-Daten
    except Exception as e:
        app.logger.error(f"💥 Metacritic-Fehler: {str(e)}")

    # 6. Datenbank-Update
    try:
        db.session.commit()
        flash(translate('Externe Daten erfolgreich aktualisiert!'), 'success')
        app.logger.info("💾 Datenbank-Update erfolgreich")
    except Exception as e:
        db.session.rollback()
        app.logger.error(f"💥 Datenbank-Fehler: {str(e)}", exc_info=True)
        flash(translate('Fehler beim Speichern der Daten'), 'danger')

    return redirect(url_for('edit_game', game_id=game_id))


@app.route('/game/<int:game_id>')
@login_required
def game_details(game_id):
    game = Game.query.get_or_404(game_id)
    return render_template('game_details.html', game=game)


@app.route('/debug-session')
def debug_session():
    return jsonify(dict(session))

# Apprise Notifications
import apprise

def send_apprise_notification(user, game):
    apprise_urls = os.getenv('APPRISE_URLS', '').strip()
    if not apprise_urls:
        app.logger.error("No APPRISE_URLS configured")
        return False

    apobj = apprise.Apprise()
    for url in apprise_urls.replace(',', '\n').splitlines():
        if url.strip():
            apobj.add(url.strip())

    edit_url = url_for('edit_game', game_id=game.id, _external=True)
    result = apobj.notify(
        title="Steam-Key läuft ab!",
        body=f"Dein Key für '{game.name}' läuft in weniger als 48 Stunden ab!\n\nLink: {edit_url}",
    )
    return result

def send_notification(user, game):
    return send_apprise_notification(user, game)

def check_expiring_keys():
    now = datetime.now(local_tz)
    expiry_threshold = now + timedelta(hours=48)

    stmt = select(Game).where(
        Game.status != 'eingelöst',
        Game.redeem_date <= expiry_threshold,
        Game.redeem_date > now
    )
    
    expiring_games = db.session.execute(stmt).scalars().all()
    
    for game in expiring_games:
        user = User.query.get(game.user_id)
        if user.notification_service and user.notification_service != 'none':
            send_notification(user, game)


# Optional: cleaning up old tokens
def cleanup_expired_tokens():
    with app.app_context():
        try:
            now = datetime.now(local_tz)
            expired = RedeemToken.query.filter(RedeemToken.expires < now).all()
            for token in expired:
                db.session.delete(token)
            db.session.commit()
            app.logger.info(f"Cleaned up {len(expired)} expired tokens.")
        except Exception as e:
            app.logger.error(f"Error during cleanup_expired_tokens: {e}")
            db.session.rollback()


# Scheduler start
scheduler = BackgroundScheduler(timezone=str(local_tz))

def check_expiring_keys_job():
    with app.app_context():
        check_expiring_keys()

def cleanup_expired_tokens_job():
    with app.app_context():
        cleanup_expired_tokens()

# Jobs hinzufügen
scheduler.add_job(
    check_expiring_keys_job,
    'interval',
    hours=int(os.getenv('CHECK_EXPIRING_KEYS_INTERVAL_HOURS', 12)),
    id='check_expiring_keys'
)
scheduler.add_job(
    cleanup_expired_tokens_job,
    'interval',
    hours=1,
    id='cleanup_expired_tokens'
)
# price updates
def update_prices_job():
    with app.app_context():
        games = Game.query.filter(Game.steam_appid.isnot(None)).all()
        for game in games:
            # Nur Preise aktualisieren
            itad_data = fetch_itad_data(f"app/{game.steam_appid}")
            if itad_data:
                game.current_price = itad_data.get('price_new')
                game.historical_low = itad_data.get('price_low', {}).get('amount')
        db.session.commit()

scheduler.add_job(
    update_prices_job,
    'interval',
    hours=12,
    id='update_prices'
)


# start Scheduler 
scheduler.start()
atexit.register(lambda: scheduler.shutdown(wait=False))

if __name__ == '__main__':
    with app.app_context():
        db.create_all()
    app.run(debug=True, host='0.0.0.0', port=5000)

PYTHON_END


# 9. Templates
mkdir -p templates static

# Base Template
cat <<HTML_END > templates/base.html
<!DOCTYPE html>
<html lang="{{ session.get('lang', 'en') }}" data-bs-theme="{{ theme }}">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta name="csrf-token" content="{{ csrf_token() }}">
    <meta name="description" content="Manage your Steam and GOG keys efficiently. Track redemption dates, share games, and export lists.">
    <meta name="theme-color" content="#212529">
    <link rel="manifest" href="{{ url_for('static', filename='manifest.json') }}">
    <title>{{ _('Game Key Manager') }}</title>
    <!-- Preload Bootstrap CSS for better LCP -->
    <link rel="preload" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" as="style" onload="this.onload=null;this.rel='stylesheet'">
    <noscript><link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css"></noscript>
    <!-- My Styles -->
    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
    {% if games and games[0].steam_appid %}
    <link rel="preload"
          as="image"
          href="https://cdn.cloudflare.steamstatic.com/steam/apps/{{ games[0].steam_appid }}/header.jpg"
          imagesrcset="https://cdn.cloudflare.steamstatic.com/steam/apps/{{ games[0].steam_appid }}/header.jpg 368w"
          fetchpriority="high"
          type="image/jpeg">
    {% endif %}
</head>
<script>
(function() {
  try {
    var theme = localStorage.getItem('theme');
    if (!theme) {
      // Systempräferenz als Fallback
      theme = window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
    }
    document.documentElement.setAttribute('data-bs-theme', theme);
  } catch(e) {}
})();
</script>
<body>
<nav class="navbar navbar-expand-lg bg-body-tertiary">
  <div class="container">
    <a class="navbar-brand d-flex align-items-center gap-2" href="/">
      <img src="{{ url_for('static', filename='logo_small.webp') }}" alt="Logo" width="36" height="28" style="object-fit:contain; border-radius:8px;">
      <span>Game Key Manager</span>
    </a>
    <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#mainNavbar" aria-controls="mainNavbar" aria-expanded="false" aria-label="Toggle navigation">
      <span class="navbar-toggler-icon"></span>
    </button>
    <div class="collapse navbar-collapse flex-grow-1" id="mainNavbar">
      <form class="d-flex ms-auto my-2 my-lg-0" action="{{ url_for('index') }}" method="GET" role="search" aria-label="{{ _('Search games') }}">
        <input class="form-control me-2" type="search" name="q" id="searchInput" placeholder="{{ _('Search') }}" value="{{ search_query }}">
        <button class="btn btn-outline-success" type="submit" aria-label="{{ _('Search') }}">🔍</button>
      </form>
      <ul class="navbar-nav ms-lg-3 mb-2 mb-lg-0">
        <li class="nav-item dropdown">
          <a class="nav-link dropdown-toggle" href="#" id="langDropdown" role="button" data-bs-toggle="dropdown" aria-expanded="false">
            {% if session.get('lang', 'en') == 'de' %} Deutsch {% elif session.get('lang', 'en') == 'en' %} English {% else %} Sprache {% endif %}
          </a>
          <ul class="dropdown-menu" aria-labelledby="langDropdown">
            <li><a class="dropdown-item {% if session.get('lang', 'en') == 'de' %}active{% endif %}" href="{{ url_for('set_lang', lang='de') }}">Deutsch</a></li>
            <li><a class="dropdown-item {% if session.get('lang', 'en') == 'en' %}active{% endif %}" href="{{ url_for('set_lang', lang='en') }}">English</a></li>
          </ul>
        </li>
        {% if current_user.is_authenticated %}
          {% if current_user.is_admin %}
          <li class="nav-item"><a class="nav-link" href="{{ url_for('admin_users') }}">⚙️ {{ _('Admin') }}</a></li>
          <li class="nav-item"><a class="nav-link" href="{{ url_for('admin_audit_logs') }}">📜 {{ _('Audit Logs') }}</a></li>
          {% endif %}
          <li class="nav-item"><a class="nav-link" href="{{ url_for('change_password') }}">🔒 {{ _('Password') }}</a></li>
          <li class="nav-item"><a class="nav-link" href="{{ url_for('logout') }}">🚪 {{ _('Logout') }}</a></li>
        {% endif %}
      </ul>
    </div>
  </div>
</nav>
    <div class="container mt-4">
        {% with messages = get_flashed_messages(with_categories=true) %}
            {% if messages %}
                <div class="flash-container">
                  {% for category, message in messages %}
                    <div class="alert alert-{{ category }} alert-dismissible fade show" role="alert">
                      {{ message|safe }}
                    <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
                    </div>
                  {% endfor %}
                </div>
            {% endif %}
        {% endwith %}
        {% block content %}{% endblock %}
    </div>
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/js/bootstrap.bundle.min.js"></script>
    <script>
    // Service Worker Registration for PWA
    if ('serviceWorker' in navigator) {
      window.addEventListener('load', () => {
        navigator.serviceWorker.register('{{ url_for("static", filename="serviceworker.js") }}', {scope: '/'})
          .then(registration => {
            console.log('ServiceWorker registered:', registration.scope);
          })
          .catch(error => {
            console.log('ServiceWorker registration failed:', error);
          });
      });
    }
    // Dark Mode Switch
    document.addEventListener('DOMContentLoaded', function() {
        const toggle = document.getElementById('darkModeSwitch');
        const html = document.documentElement;
        if (toggle) {
            toggle.checked = (html.getAttribute('data-bs-theme') === 'dark')
            toggle.addEventListener('change', function() {
                const theme = this.checked ? 'dark' : 'light';
                document.cookie = "theme=" + theme + ";path=/;max-age=31536000";
                html.setAttribute('data-bs-theme', theme);
                fetch('/set-theme/' + theme);
            });
        }
        // Set theme on page load
        function getThemeCookie() {
          const cookies = document.cookie.split(';');
            for (let cookie of cookies) {
              const [name, value] = cookie.trim().split('=');
              if (name === 'theme') return value;
            }
            return null;
        }
        const savedTheme = getThemeCookie() || (window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light');
        document.documentElement.setAttribute('data-bs-theme', savedTheme);
    });

    </script>
{% include "footer.html" %}
</body>
</html>
HTML_END

# Index Template
cat <<'HTML_END' > templates/index.html
{% extends "base.html" %}
{% block content %}
<div class="d-flex justify-content-between align-items-center mb-4">
    <h1>{{ _('My Games') }}</h1>
    <div>
        <a href="{{ url_for('export_games') }}" class="btn btn-outline-secondary">⬇️ {{ _('Export CSV') }}</a>
        <a href="{{ url_for('export_pdf') }}" class="btn btn-outline-secondary">⬇️ Export PDF (for sharing)</a>
        <a href="{{ url_for('import_games') }}" class="btn btn-outline-secondary">⬆️ {{ _('Import CSV') }}</a>
        <a href="{{ url_for('add_game') }}" class="btn btn-primary">+ {{ _('Add New Game') }}</a>
    </div>
</div>

{% if games %}
<div class="table-responsive">
    <table class="table table-hover align-middle">
        <thead class="table-dark">
            <tr>
                <th>{{ _('Cover') }}</th>
                <th>{{ _('Name') }}</th>
                <th>{{ _('Key') }}</th>
                <th>{{ _('Status') }}</th>
                <th>{{ _('Created') }}</th>
                <th>{{ _('Redeem by') }}</th>
                <th>{{ _('Shop') }}</th>
                <th>{{ _('Price') }}</th>
                <th>{{ _('Metascore') }}</th>
                <th>{{ _('Actions') }}</th>
            </tr>
        </thead>
        <tbody>
            {% for game in games %}
            <tr>
                <td>
                {% if game.steam_appid %}
                <img src="https://cdn.cloudflare.steamstatic.com/steam/apps/{{ game.steam_appid }}/header.jpg"
                     alt="Steam Header" 
                     class="game-cover"
                     {% if loop.first %}fetchpriority="high"{% endif %}
                     width="368" 
                     height="172"
                     loading="lazy">
                {% elif game.url and 'gog.com' in game.url %}
                <img src="{{ url_for('static', filename='gog_logo.webp') }}"
                     alt="GOG Logo" 
                     class="game-cover"
                     width="368"
                     height="172"
                     loading="lazy">
                {% endif %}
                </td>
                <td>{{ game.name }}</td>
                <td class="font-monospace">{{ game.steam_key }}</td>
                <td>
                    {% if game.status == 'nicht eingelöst' %}
                        <span class="badge bg-warning text-dark">{{ _('Not redeemed') }}</span>
                    {% elif game.status == 'geschenkt' %}
                        <span class="badge bg-success">{{ _('Gifted') }}</span>
                    {% elif game.status == 'eingelöst' %}
                        <span class="badge bg-secondary">{{ _('Redeemed') }}</span>
                    {% endif %}
                </td>
                <td>{{ game.created_at|strftime('%d.%m.%Y') }}</td>
                <td>
                    {% if game.redeem_date %}
                        <span class="badge bg-danger">{{ game.redeem_date|strftime('%d.%m.%Y') }}</span>
                    {% endif %}
                </td>
                <td>
                    {% if game.url %}
                        <a href="{{ game.url }}" target="_blank" class="btn btn-sm btn-outline-info">🔗 {{ _('Shop') }}</a>
                    {% endif %}
                </td>
                <td>
                  {% if game.current_price %}
                    <div class="text-center mb-2">
                      <span class="badge bg-primary d-block">{{ _('Now') }}</span>
                        {{ "%.2f"|format(game.current_price) }} €
                      </div>
                    </div>
                  {% endif %}
                  {% if game.historical_low %}
                    <div class="text-center">
                      <span class="badge bg-secondary d-block">{{ _('Hist. Low') }}</span>
                        {{ "%.2f"|format(game.historical_low) }} €
                      </div>
                    </div>
                  {% endif %}
                </td>
                <td>
                   {% if game.metacritic_score %}
                   <span class="badge {% if game.metacritic_score >= 75 %}bg-success{% elif game.metacritic_score >= 50 %}bg-warning{% else %}bg-danger{% endif %}">
                   {{ game.metacritic_score }}
                   </span>
                   {% endif %}
                </td>
                <td class="text-nowrap">
                    {% if game.status == 'geschenkt' %}
                    <button type="button" 
                            class="btn btn-sm btn-success generate-redeem" 
                            data-game-id="{{ game.id }}"
                            title="{{ _('Generate redeem link') }}">
                        🔗
                    </button>
                    {% endif %}
                    <a href="{{ url_for('edit_game', game_id=game.id) }}" class="btn btn-sm btn-warning">✏️</a>
                    <form method="POST" action="{{ url_for('delete_game', game_id=game.id) }}" class="d-inline">
                        <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
                        <button type="submit" class="btn btn-sm btn-danger" onclick="return confirm('{{ _('Really delete?') }}')">🗑️</button>
                    </form>
                </td>
            </tr>
            {% endfor %}
        </tbody>
    </table>
</div>
<script>
document.querySelectorAll('.generate-redeem').forEach(btn => {
    btn.addEventListener('click', async function() {
        const gameId = this.dataset.gameId;
        const flashContainer = document.querySelector('.flash-container');
        
        try {
            const response = await fetch(`/generate_redeem/${gameId}`, {
                method: 'POST',
                headers: {
                    'X-CSRFToken': document.querySelector('meta[name="csrf-token"]').content,
                    'Accept': 'application/json'
                }
            });

            const data = await response.json();
            
            if (!response.ok) {
                throw new Error(data.error || '{{ _("Unknown error") }}');
            }

            if (data.url) {
                await navigator.clipboard.writeText(data.url);
                
                // Erfolgsmeldung mit übersetztem Text
                flashContainer.innerHTML = `
                    <div class="alert alert-success alert-dismissible fade show" role="alert">
                        {{ _("Link copied") }}: <a href="${data.url}" target="_blank">${data.url}</a>
                        <button type="button" class="btn-close" data-bs-dismiss="alert"></button>
                    </div>
                `;
            }
        } catch (error) {
            // Fehlermeldung mit übersetztem Text
            flashContainer.innerHTML = `
                <div class="alert alert-danger alert-dismissible fade show" role="alert">
                    {{ _("Error") }}: ${error.message}
                    <button type="button" class="btn-close" data-bs-dismiss="alert"></button>
                </div>
            `;
        }
    });
});
</script>
{% else %}
<div class="alert alert-info">{{ _('No games yet') }}</div>
{% endif %}
{% endblock %}
HTML_END

# Login Template
cat <<HTML_END > templates/login.html
{% extends "base.html" %}
{% block content %}
<div class="row justify-content-center">
  <div class="col-md-6 col-lg-4">
    <h1 class="mb-4">{{ _('Login') }}</h1>
    <form method="POST" aria-label="{{ _('Login form') }}" autocomplete="on">
      <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
      <div class="mb-3">
        <label for="username" class="form-label">{{ _('Username') }} <span aria-hidden="true" class="text-danger">*</span></label>
        <input type="text"
               id="username"
               name="username"
               class="form-control"
               required
               autocomplete="username"
               aria-required="true"
               autofocus>
      </div>
      <div class="mb-3">
        <label for="password" class="form-label">{{ _('Password') }} <span aria-hidden="true" class="text-danger">*</span></label>
        <input type="password"
               id="password"
               name="password"
               class="form-control"
               required
               autocomplete="current-password"
               aria-required="true">
      </div>
      {% if error %}
      <div class="alert alert-danger" role="alert">
        {{ error }}
      </div>
      {% endif %}
      <button type="submit" class="btn btn-primary w-100">{{ _('Login') }}</button>
    </form>
    <div class="mt-3 text-center">
      {% if config['REGISTRATION_ENABLED'] %}
        <a href="{{ url_for('register') }}">{{ _('No account? Register here!') }}</a>
      {% endif %}
    </div>
  </div>
</div>
{% endblock %}


HTML_END

# Register Template
cat <<HTML_END > templates/register.html
{% extends "base.html" %}
{% block content %}
<div class="row justify-content-center">
  <div class="col-md-6 col-lg-4">
    <h1 class="mb-4">{{ _('Register') }}</h1>
    <form method="POST" aria-label="{{ _('Registration form') }}" autocomplete="on">
      <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
      <div class="mb-3">
        <label for="reg-username" class="form-label">{{ _('Username') }} <span aria-hidden="true" class="text-danger">*</span></label>
        <input type="text"
               id="reg-username"
               name="username"
               class="form-control"
               required
               autocomplete="username"
               aria-required="true">
      </div>
      <div class="mb-3">
        <label for="reg-password" class="form-label">{{ _('Password') }} <span aria-hidden="true" class="text-danger">*</span></label>
        <input type="password"
               id="reg-password"
               name="password"
               class="form-control"
               required
               autocomplete="new-password"
               aria-required="true">
      </div>
      <div class="mb-3">
        <label for="reg-password2" class="form-label">{{ _('Confirm Password') }} <span aria-hidden="true" class="text-danger">*</span></label>
        <input type="password"
               id="reg-password2"
               name="password2"
               class="form-control"
               required
               autocomplete="new-password"
               aria-required="true">
      </div>
      {% if error %}
      <div class="alert alert-danger" role="alert">
        {{ error }}
      </div>
      {% endif %}
      <button type="submit" class="btn btn-primary w-100">{{ _('Register') }}</button>
    </form>
    <div class="mt-3 text-center">
      <a href="{{ url_for('login') }}">{{ _('Already have an account? Login!') }}</a>
    </div>
  </div>
</div>
{% endblock %}

HTML_END

# Change Password Template
cat <<HTML_END > templates/change_password.html
{% extends "base.html" %}
{% block content %}
<div class="row justify-content-center">
  <div class="col-md-6 col-lg-5">
    <div class="card p-4 shadow-sm">
      <h2 class="mb-4">{{ _('Change Password') }}</h2>
      <form method="POST" aria-label="{{ _('Change password form') }}">
        <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
        <div class="mb-3">
          <label for="current_password" class="form-label">{{ _('Current Password') }} <span aria-hidden="true" class="text-danger">*</span></label>
          <input type="password" id="current_password" name="current_password" class="form-control" required autocomplete="current-password" aria-required="true">
        </div>
        <div class="mb-3">
          <label for="new_password" class="form-label">{{ _('New Password') }} <span aria-hidden="true" class="text-danger">*</span></label>
          <input type="password" id="new_password" name="new_password" class="form-control" required autocomplete="new-password" aria-required="true">
        </div>
        <div class="mb-3">
          <label for="confirm_password" class="form-label">{{ _('Confirm New Password') }} <span aria-hidden="true" class="text-danger">*</span></label>
          <input type="password" id="confirm_password" name="confirm_password" class="form-control" required autocomplete="new-password" aria-required="true">
        </div>
        <button type="submit" class="btn btn-primary">{{ _('Change Password') }}</button>
        <a href="{{ url_for('index') }}" class="btn btn-outline-secondary ms-2">{{ _('Cancel') }}</a>
      </form>
    </div>
  </div>
</div>
{% endblock %}

HTML_END


# Edit Game Template
cat <<HTML_END > templates/edit_game.html
{% extends "base.html" %}
{% block content %}
<div class="card p-4 shadow-sm">
  <h2 class="mb-4">{{ _('Spiel bearbeiten') }}</h2>
  
  <!-- Flash-Nachrichten -->
  {% with messages = get_flashed_messages(with_categories=true) %}
    {% if messages %}
      <div class="flash-messages mb-4">
        {% for category, message in messages %}
          <div class="alert alert-{{ 'danger' if category == 'error' else category }} alert-dismissible fade show">
            {{ message|safe }}
            <button type="button" class="btn-close" data-bs-dismiss="alert"></button>
          </div>
        {% endfor %}
      </div>
    {% endif %}
  {% endwith %}
  
  <form method="POST" aria-label="{{ _('Spiel bearbeiten') }}">
    <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
    <div class="row g-3">
      <!-- Hauptformularfelder -->
      <div class="col-md-6">
        <label class="form-label">{{ _('Name') }} <span class="text-danger">*</span></label>
        <input type="text" name="name" class="form-control" value="{{ game.name }}" required>
      </div>
      <div class="col-md-6">
        <label for="game_platform" class="form-label">{{ _('Platform') }} <span class="text-danger">*</span></label>
        <select id="game_platform" name="platform" class="form-select" required>
          {% for value, label in platforms %}
            <option value="{{ value }}" {% if game.platform == value %}selected{% endif %}>
              {{ _(label) }}
            </option>
          {% endfor %}
        </select>
      </div>
      <div class="col-md-6">
        <label for="game_status" class="form-label">{{ _('Status') }} <span class="text-danger">*</span></label>
        <select id="game_status" name="status" class="form-select" required>
          {% for value, label in statuses %}
            <option value="{{ value }}" {% if game.status == value %}selected{% endif %}>
              {{ _(label) }}
            </option>
          {% endfor %}
        </select>
      </div>
      <div class="col-md-6">
        <label class="form-label">{{ _('Steam Key') }} <span class="text-danger">*</span></label>
        <input type="text" name="steam_key" class="form-control" value="{{ game.steam_key }}" required>
      </div>
      <div class="col-md-6">
          <label for="game_appid" class="form-label">{{ _('Steam AppID') }}</label>
          <input type="text" 
                id="game_appid" 
                name="steam_appid" 
                class="form-control" 
                value="{{ game.steam_appid or '' }}">
      </div>

      <!-- Redeem Date -->
      <div class="col-md-6">
          <label for="game_redeem_date" class="form-label">{{ _('Redeem by') }}</label>
          <input type="date" 
                id="game_redeem_date" 
                name="redeem_date" 
                class="form-control"
                value="{{ game.redeem_date.strftime('%Y-%m-%d') if game.redeem_date else '' }}">
      </div>

      <!-- Recipient -->
      <div class="col-12">
          <label for="game_recipient" class="form-label">{{ _('Recipient') }}</label>
          <input type="text" 
                id="game_recipient" 
                name="recipient" 
                class="form-control" 
                value="{{ game.recipient }}">
      </div>

      <!-- Shop URL -->
      <div class="col-12">
          <label for="game_url" class="form-label">{{ _('Shop URL') }}</label>
          <input type="url" 
                id="game_url" 
                name="url" 
                class="form-control" 
                value="{{ game.url }}">
      </div>

      <!-- Notes -->
      <div class="col-12">
          <label for="game_notes" class="form-label">{{ _('Notes') }}</label>
          <textarea id="game_notes" 
                    name="notes" 
                    class="form-control" 
                    rows="3">{{ game.notes }}</textarea>
      </div>
  </div>
      <!-- Externe Daten Card -->
      <div class="col-12">
        <div class="card mb-4">
          <div class="card-header d-flex justify-content-between align-items-center">
            <span>🔄 {{ _('Externe Daten') }}</span>
            <form method="POST" action="{{ url_for('update_game_data', game_id=game.id) }}">
              <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
              <input type="hidden" name="steam_appid_to_update" value="{{ game.steam_appid }}">
              <button type="submit" 
                      formaction="{{ url_for('update_game_data', game_id=game.id) }}"
                      name="update_data"
                      value="1"
                      class="btn btn-secondary">
                Update Data
              </button>
            </form>
          </div>
          <div class="card-body">
            {% if game.release_date %}
              <div class="mb-2">
                <strong>{{ _('Veröffentlichung:') }}</strong>
                {{ game.release_date|strftime('%d.%m.%Y') }}
              </div>
            {% endif %}

            <!-- Preisanzeige -->
            <td>
            <td>
              {% if game.current_price %}
                <div class="text-center mb-2">
                  <span class="badge bg-primary d-block">{{ _('Now') }}</span>
                  <div class="fw-bold" style="font-size:1.1em;">
                    {{ "%.2f"|format(game.current_price) }} €
                  </div>
                </div>
              {% endif %}
              {% if game.historical_low %}
                <div class="text-center">
                  <span class="badge bg-secondary d-block">{{ _('Hist. Low') }}</span>
                  <div class="fw-bold" style="font-size:1.1em;">
                    {{ "%.2f"|format(game.historical_low) }} €
                  </div>
                </div>
              {% endif %}
            </td>
            <!-- ITAD-Link -->
            {% if game.itad_slug %}
              <a href="https://isthereanydeal.com/game/{{ game.itad_slug }}/info/"
                target="_blank"
                rel="noopener"
                class="btn btn-outline-info">
                🔗 {{ _('View on IsThereAnyDeal') }}
              </a>
            {% endif %}
          </div>
        </div>
      </div>

      <!-- Einlöse-Links -->
      {% if game.status == 'geschenkt' %}
        <div class="col-12">
          <div class="card mb-3">
            <div class="card-header">{{ _('Einlöse-Links') }}</div>
            <div class="card-body">
            {% for token in game.redeem_tokens if not token.is_expired() %}
            <div class="input-group mb-3">
              <input type="text" 
                    class="form-control" 
                    value="{{ url_for('redeem', token=token.token, _external=True) }}"
                    readonly
                    id="redeem-link-{{ loop.index }}">
              <button type="button"
                      class="btn btn-outline-secondary copy-btn"
                      data-clipboard-target="#redeem-link-{{ loop.index }}">
                {{ _('Copy') }}
              </button>
            </div>
              <small class="text-muted">
                {{ _('Expires at') }}: {{ token.expires.astimezone(local_tz).strftime('%d.%m.%Y %H:%M') }}
              </small>
            {% else %}
              <p class="text-muted mb-0">{{ _('No active redeem links') }}</p>
            {% endfor %}
            </div>
          </div>
        </div>
      {% endif %}
      <a href="{{ url_for('game_details', game_id=game.id) }}" 
        class="btn btn-info ms-2">
          🔍 {{ _('View Details') }}
      </a>
      <!-- Buttons -->
      <div class="col-12">
        <button type="submit" class="btn btn-primary">{{ _('Save') }}</button>
        <a href="{{ url_for('index') }}" class="btn btn-outline-secondary ms-2">{{ _('Cancel') }}</a>
      </div>
    </div>
  </form>
</div>

<!-- Copy-JavaScript -->
<script>
document.querySelectorAll('.copy-btn').forEach(btn => {
  btn.addEventListener('click', async function() {
    const input = document.querySelector(this.dataset.clipboardTarget);
    try {
      await navigator.clipboard.writeText(input.value);
      this.innerHTML = '✅ {{ _("Copied!") }}';
      setTimeout(() => this.innerHTML = '{{ _("Copy") }}', 2000);
    } catch (err) {
      this.innerHTML = '❌ {{ _("Error") }}';
      setTimeout(() => this.innerHTML = '{{ _("Copy") }}', 2000);
    }
  });
});
</script>

{% endblock %}

HTML_END

cat <<HTML_END > templates/add_game.html
{% extends "base.html" %}
{% block content %}
<div class="card p-4 shadow-sm">
  <h2 class="mb-4">{{ _('Add Game') }}</h2>
  {% with messages = get_flashed_messages(with_categories=true) %}
    {% if messages %}
      <div class="mb-3">
        {% for category, message in messages %}
          <div class="alert alert-{{ 'danger' if category == 'error' else category }}">
            {{ message|safe }}
          </div>
        {% endfor %}
      </div>
    {% endif %}
  {% endwith %}
  <form method="POST" aria-label="{{ _('Add Game') }}">
    <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
    <div class="row g-3">
      <!-- Name -->
      <div class="col-md-6">
        <label for="game_name" class="form-label">{{ _('Name') }} <span class="text-danger">*</span></label>
        <input type="text" id="game_name" name="name" class="form-control" value="{{ request.form.name or '' }}" required>
      </div>

      <!-- Steam Key -->
      <div class="col-md-6">
        <label for="game_key" class="form-label">{{ _('Game Key') }} <span class="text-danger">*</span></label>
        <input type="text" id="game_key" name="steam_key" class="form-control" value="{{ request.form.steam_key or '' }}" required>
      </div>

      <!-- Platform Dropdown -->
      <div class="col-md-6">
        <label for="game_platform" class="form-label">{{ _('Platform') }} <span class="text-danger">*</span></label>
        <select id="game_platform" name="platform" class="form-select" required>
          {% for value, label in platforms %}
            <option value="{{ value }}" {% if request.form.platform == value %}selected{% endif %}>
              {{ _(label) }}
            </option>
          {% endfor %}
        </select>
      </div>

      <!-- Status Dropdown -->
      <div class="col-md-6">
        <label for="game_status" class="form-label">{{ _('Status') }} <span class="text-danger">*</span></label>
        <select id="game_status" name="status" class="form-select" required>
          {% for value, label in statuses %}
            <option value="{{ value }}" {% if request.form.status == value %}selected{% endif %}>
              {{ _(label) }}
            </option>
          {% endfor %}
        </select>
      </div>

      <!-- Steam AppID -->
      <div class="col-md-6">
        <label for="game_appid" class="form-label">{{ _('Steam AppID (optional)') }}</label>
        <input type="text" id="game_appid" name="steam_appid" class="form-control" value="{{ request.form.steam_appid or '' }}">
      </div>

      <!-- Redeem Date -->
      <div class="col-md-6">
        <label for="game_redeem_date" class="form-label">{{ _('Redeem by') }}</label>
        <input type="date" id="game_redeem_date" name="redeem_date" class="form-control" value="{{ request.form.redeem_date or '' }}">
      </div>

      <!-- Recipient -->
      <div class="col-12">
        <label for="game_recipient" class="form-label">{{ _('Recipient') }}</label>
        <input type="text" id="game_recipient" name="recipient" class="form-control" value="{{ request.form.recipient or '' }}">
      </div>

      <!-- Shop URL -->
      <div class="col-12">
        <label for="game_url" class="form-label">{{ _('Shop URL') }}</label>
        <input type="url" id="game_url" name="url" class="form-control" value="{{ request.form.url or '' }}">
      </div>

      <!-- Notes -->
      <div class="col-12">
        <label for="game_notes" class="form-label">{{ _('Notes') }}</label>
        <textarea id="game_notes" name="notes" class="form-control" rows="3">{{ request.form.notes or '' }}</textarea>
      </div>

      <!-- Buttons -->
      <div class="col-12">
        <button type="submit" class="btn btn-primary">{{ _('Save') }}</button>
        <a href="{{ url_for('index') }}" class="btn btn-outline-secondary ms-2">{{ _('Cancel') }}</a>
      </div>
    </div>
  </form>
</div>
{% endblock %}

HTML_END

# Import/Export Templates
cat <<HTML_END > templates/import.html
{% extends "base.html" %}
{% block content %}
<div class="card p-4 shadow-sm">
    <h2 class="mb-4">{{ _('Import Games') }}</h2>
    <form method="POST" enctype="multipart/form-data">
	<input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
        <div class="mb-3">
            <label class="form-label">{{ _('Select CSV file') }}</label>
            <input type="file" name="file" class="form-control" accept=".csv" required>
        </div>
        <button type="submit" class="btn btn-success">{{ _('Import') }}</button>
        <a href="{{ url_for('index') }}" class="btn btn-outline-secondary">{{ _('Cancel') }}</a>
    </form>
</div>
{% endblock %}
HTML_END

# Redeem Template
cat <<'HTML_END' > templates/redeem.html
{% extends "base.html" %}
{% block content %}
<div class="container mt-5">
    <div class="card shadow-lg">
        <div class="row g-0">
            {% if game.steam_appid %}
            <div class="col-md-4">
                <img src="https://cdn.cloudflare.steamstatic.com/steam/apps/{{ game.steam_appid }}/header.jpg" 
                     class="img-fluid rounded-start" alt="Game Cover">
            </div>
            {% endif %}
            <div class="col-md-8">
                <div class="card-body">
                    <h1 class="card-title mb-4">{{ game.name }}</h1>
                    <div class="alert alert-success">
                        <h4>{{ _('Your Key:') }}</h4>
                        <code class="fs-3">{{ game.steam_key }}</code>
                    </div>
                    <a href="{{ platform_link }}{{ game.steam_key }}" 
                       class="btn btn-primary btn-lg mb-3"
                       target="_blank">
                        {{ _('Redeem now on') }} {% if game.steam_appid %}Steam{% else %}GOG{% endif %}
                    </a>
                    <div class="mt-4 text-muted">
                        <small>
                            {{ _('This page will expire in') }} 
                            <span id="expiry-countdown" class="fw-bold"></span>
                        </small>
                        <div class="progress mt-2" style="height: 8px;">
                            <div id="expiry-bar" 
                                class="progress-bar bg-danger" 
                                role="progressbar" 
                                style="width: 100%">
                            </div>
                        </div>
                    </div>
                </div>
            </div>
        </div>
    </div>
</div>
<script>
const totalDuration = {{ redeem_token.total_hours * 3600 * 1000 }};  // Gesamtdauer in Millisekunden
const expires = {{ expires_timestamp }};
const countdownEl = document.getElementById('expiry-countdown');
const progressBar = document.getElementById('expiry-bar');
const csrfToken = document.querySelector('meta[name="csrf-token"]').getAttribute('content');

function formatTime(unit) {
    return unit < 10 ? `0${unit}` : unit;
}

function updateProgressBar(percentage) {
    // Alle Farbklassen entfernen
    progressBar.classList.remove('bg-success', 'bg-warning', 'bg-danger');
    
    if (percentage > 75) {
        progressBar.classList.add('bg-success');
    } else if (percentage > 25) {
        progressBar.classList.add('bg-warning');
    } else {
        progressBar.classList.add('bg-danger');
    }
}

function updateCountdown() {
    const now = Date.now();
    const remaining = expires - now;
    const percent = (remaining / totalDuration) * 100;

    if (remaining < 0) {
        countdownEl.innerHTML = "EXPIRED";
        progressBar.style.width = "0%";
        clearInterval(timer);
        setTimeout(() => window.location.reload(), 5000);
        return;
    }

    const hours = Math.floor(remaining / (1000 * 60 * 60));
    const minutes = Math.floor((remaining % (1000 * 60 * 60)) / (1000 * 60));
    const seconds = Math.floor((remaining % (1000 * 60)) / 1000);

    countdownEl.innerHTML = `${formatTime(hours)}h ${formatTime(minutes)}m ${formatTime(seconds)}s`;
    progressBar.style.width = `${percent}%`;
    updateProgressBar(percent);
}

// run countdown
updateCountdown();
const timer = setInterval(updateCountdown, 1000);
</script>
{% endblock %}
HTML_END

# Game Details Templates
cat <<HTML_END > templates/game_details.html
{% extends "base.html" %}
{% block content %}
<div class="card shadow-sm">
    <div class="card-body">
        <h1>{{ game.name }}</h1>
        
        <div class="row">
            <!-- Bild und Basis-Infos -->
            <div class="col-md-4">
                {% if game.steam_appid %}
                <img src="https://cdn.cloudflare.steamstatic.com/steam/apps/{{ game.steam_appid }}/header.jpg" 
                     class="img-fluid rounded mb-3" 
                     alt="{{ game.name }} Cover"
                     loading="lazy">
                {% endif %}
            </div>

            <!-- Details -->
            <div class="col-md-8">
                <dl class="row">
                    <dt class="col-sm-3">{{ _('Status') }}</dt>
                    <dd class="col-sm-9">
                        {% if game.status == 'nicht eingelöst' %}
                            <span class="badge bg-warning text-dark">{{ _('Not redeemed') }}</span>
                        {% elif game.status == 'geschenkt' %}
                            <span class="badge bg-success">{{ _('Gifted') }}</span>
                        {% elif game.status == 'eingelöst' %}
                            <span class="badge bg-secondary">{{ _('Redeemed') }}</span>
                        {% endif %}
                    </dd>
                    
                    <dt class="col-sm-3">{{ _('Release Date') }}</dt>
                    <dd class="col-sm-9">{{ game.release_date|strftime('%d.%m.%Y') if game.release_date else 'N/A' }}</dd>
                    
                    <dt class="col-sm-3">{{ _('Current Price') }}</dt>
                    <dd class="col-sm-9">{{ "%.2f €"|format(game.current_price) if game.current_price else 'N/A' }}</dd>
                    
                    <dt class="col-sm-3">{{ _('Metascore') }}</dt>
                    <dd class="col-sm-9">
                        {% if game.metacritic_score %}
                        <span class="badge 
                            {% if game.metacritic_score >= 75 %}bg-success
                            {% elif game.metacritic_score >= 50 %}bg-warning
                            {% else %}bg-danger{% endif %}">
                            {{ game.metacritic_score }}
                        </span>
                        {% else %}
                        N/A
                        {% endif %}
                    </dd>
                </dl>
                
                <a href="{{ url_for('edit_game', game_id=game.id) }}" class="btn btn-primary">
                    {{ _('Edit') }}
                </a>
            </div>
        </div>

        <!-- Beschreibung UNTERHALB der Hauptzeile -->
        {% if game.steam_description %}
        <div class="row mt-4">
            <div class="col-12">
                <div class="card">
                    <div class="card-header">{{ _('Game Description') }}</div>
                    <div class="card-body">
                        {{ game.steam_description|safe }}
                    </div>
                </div>
            </div>
        </div>
        {% endif %}
    </div>
</div>
{% endblock %}

HTML_END

# Footer Template
cat <<HTML_END > templates/footer.html
<footer class="mt-5 py-4 bg-body-tertiary border-top">
  <div class="container text-center small text-muted">
    <div class="mb-2">
      <strong>Game Key Manager</strong> &mdash; is done by nocci
    </div>
    <div class="mb-2">
      <a href="https://git.nocci.it/nocci/GiftGamesDB" target="_blank" rel="noopener">
        <img src="{{ url_for('static', filename='forgejo.webp') }}" alt="forgejo" width="20" style="vertical-align:middle;margin-right:4px;">
        find the source code on my Forgejo
      </a>
    </div>
    <div>
      <span>feel free to donate - if you can affort it:</span>
      <a href="https://ko-fi.com/nocci" target="_blank" rel="noopener">Ko-fi</a> &middot;
      <a href="https://liberapay.com/nocci" target="_blank" rel="noopener">Liberapay</a>
    </div>
  </div>
</footer>
HTML_END

# Admin interface
cat <<HTML_END > templates/admin_users.html
{% extends "base.html" %}

{% block content %}
<div class="container mt-4">
    <h2>{{ _('User Management') }}</h2>
    <table class="table">
        <thead>
            <tr>
                <th>{{ _('Username') }}</th>
                <th>{{ _('Actions') }}</th>
            </tr>
        </thead>
        <tbody>
            {% for user in users %}
            <tr>
                <td>
                    {{ user.username }}
                    {% if user.is_admin %}<span class="badge bg-primary">Admin</span>{% endif %}
                </td>
                <td>
                    {% if user.id != current_user.id %}
                    <form method="POST" action="{{ url_for('admin_delete_user', user_id=user.id) }}" class="d-inline">
                        <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
                        <button type="submit" class="btn btn-danger btn-sm">{{ _('Delete') }}</button>
                    </form>
                    
                    <form method="POST" action="{{ url_for('admin_reset_password', user_id=user.id) }}">
                        <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
                        <button type="submit" class="btn btn-warning">{{ _('Reset Password') }}</button>
                    </form>
                    {% endif %}
                </td>
            </tr>
            {% endfor %}
        </tbody>
    </table>
</div>
{% endblock %}

HTML_END

# Admin Audits
cat <<HTML_END > templates/admin_audit_logs.html
{% extends "base.html" %}

{% block content %}
<div class="container mt-4">
    <h2>{{ _('Audit Logs') }}</h2>
    
    <div class="table-responsive">
        <table class="table table-hover">
            <thead>
                <tr>
                    <th>{{ _('Timestamp') }}</th>
                    <th>{{ _('User') }}</th>
                    <th>{{ _('Action') }}</th>
                    <th>{{ _('Details') }}</th>
                </tr>
            </thead>
            <tbody>
                {% for log in logs.items %}
                <tr>
                    <td>{{ log.timestamp|strftime('%d.%m.%Y %H:%M') }}</td>
                    <td>{{ log.user.username if log.user else 'System' }}</td>
                    <td>{{ log.action }}</td>
                    <td>{{ log.details|default('', true) }}</td>
                </tr>
                {% endfor %}
            </tbody>
        </table>
    </div>
    
    {% if logs.pages > 1 %}
    <nav aria-label="Page navigation">
        <ul class="pagination">
            {% if logs.has_prev %}
            <li class="page-item">
                <a class="page-link" href="{{ url_for('admin_audit_logs', page=logs.prev_num) }}">{{ _('Previous') }}</a>
            </li>
            {% endif %}
            
            {% for page_num in logs.iter_pages() %}
            <li class="page-item {% if page_num == logs.page %}active{% endif %}">
                <a class="page-link" href="{{ url_for('admin_audit_logs', page=page_num) }}">{{ page_num }}</a>
            </li>
            {% endfor %}
            
            {% if logs.has_next %}
            <li class="page-item">
                <a class="page-link" href="{{ url_for('admin_audit_logs', page=logs.next_num) }}">{{ _('Next') }}</a>
            </li>
            {% endif %}
        </ul>
    </nav>
    {% endif %}
</div>
{% endblock %}

HTML_END

# Error Site
cat <<HTML_END > templates/403.html
{% extends "base.html" %}
{% block content %}
<div class="d-flex flex-column align-items-center justify-content-center" style="min-height:60vh;">
  <div class="text-center">
    <img src="{{ url_for('static', filename='logo.webp') }}"
         alt="Forbidden"
         class="img-fluid rounded shadow mb-4"
         style="max-width: 160px;">
    <h1 class="display-3 fw-bold text-danger mb-3">403</h1>
    <h2 class="mb-4">{{ _('Access Forbidden') }}</h2>
    <p class="lead mb-4">
      <span class="d-block mb-2">{{ _('Sorry, you are not allowed to access this page.') }}</span>
      <span class="text-muted">({{ _('Registration is currently disabled.') }})</span>
    </p>
    <a href="{{ url_for('index') }}" class="btn btn-lg btn-primary shadow">
      🏠 {{ _('Back to Home') }}
    </a>
    <div class="mt-4 text-muted">
      <small>
        <span>Sorry, you haven't unlocked this area yet. Grind some more XP or check your DLC entitlements.<br>Maybe try again after the next patch?</span>
      </small>
    </div>
  </div>
</div>
{% endblock %}
HTML_END

# CSS
cat <<CSS_END > static/style.css
:root {
    --bs-body-bg: #ffffff;
    --bs-body-color: #212529;
}
[data-bs-theme="dark"] {
    --bs-body-bg: #1a1a1a;
    --bs-body-color: #f8f9fa;
    --bs-border-color: #495057;
}
[data-bs-theme="dark"] .table {
    --bs-table-bg: #212529;
    --bs-table-color: #fff;
    --bs-table-border-color: #495057;
}
[data-bs-theme="dark"] .card {
    background-color: #2b3035;
    border-color: var(--bs-border-color);
}
[data-bs-theme="dark"] .navbar {
    background-color: #212529 !important;
}
body {
    background-color: var(--bs-body-bg);
    color: var(--bs-body-color);
    transition: all 0.3s ease;
}
.font-monospace {
    font-family: Monaco, Consolas, "Courier New", monospace;
}
.badge {
    font-size: 0.9em;
    font-weight: 500;
}
#expiry-countdown {
  font-weight: 600;
  letter-spacing: 0.05em;
  color: #dc3545;
  transition: color 0.3s ease;
}

[data-bs-theme="dark"] #expiry-countdown {
  color: #ff6b6b;
}

/* Progressbar-Animations */
#expiry-bar {
    transition: width 1s linear, background-color 0.5s ease;
}

.bg-success { background-color: #198754 !important; }
.bg-warning { background-color: #ffc107 !important; }
.bg-danger { background-color: #dc3545 !important; }

.progress-bar {
  transition: width 1s linear, background-color 0.3s ease;
}
.table-pdf {
    font-size: 0.8em;
}
.table-pdf td, .table-pdf th {
    padding: 4px 8px;
}

.badge.bg-warning {
    background-color: #ffcc00 !important;
    color: #222 !important;
}
.badge.bg-success {
    background-color: #198754 !important;
    color: #fff !important;
}


.game-cover {
    width: 368px;
    height: 172px;
    max-width: 100%;
    max-height: 35vw;
    object-fit: contain;
    background: #222;
    border-radius: 8px;
    display: block;
    margin: 0 auto;
    transition: width 0.2s, height 0.2s;
}

/* Responsive Cover Images */
.game-cover {
    width: 368px;
    height: 172px;
    object-fit: contain;
    background: #222;
    border-radius: 6px;
}

@media (max-width: 1200px) {
    .game-cover {
        width: 260px;
        height: 122px;
    }
}

@media (max-width: 992px) {
    .game-cover {
        width: 180px;
        height: 84px;
    }
}

@media (max-width: 768px) {
    .game-cover {
        width: 120px;
        height: 56px;
    }
}

@media (max-width: 576px) {
    .game-cover {
        width: 90px;
        height: 42px;
    }
}

/* Accessibility Improvements */
.visually-hidden {
    position: absolute;
    width: 1px;
    height: 1px;
    padding: 0;
    margin: -1px;
    overflow: hidden;
    clip: rect(0, 0, 0, 0);
    border: 0;
}

.price-value {
  font-size: 1.2em;
  font-weight: 400;
  margin-top: 2px;
}

.navbar-nav .nav-link {
  white-space: nowrap;
}

@media (max-width: 991.98px) {
  .navbar-nav {
    flex-direction: column !important;
    align-items: flex-start !important;
  }
}
.alert-error { background-color: #f8d7da; border-color: #f5c6cb; color: #721c24; }
.alert-success { background-color: #d4edda; border-color: #c3e6cb; color: #155724; }
.alert-info { background: #d9edf7; color: #31708f; }
CSS_END


# 7. directories and permissions
mkdir -p ../data
chmod -R a+rwX ../data
find ../data -type d -exec chmod 775 {} \;
find ../data -type f -exec chmod 664 {} \;

# entrypoint.sh script
cat <<SCRIPT_END > entrypoint.sh
#!/bin/bash

# Debug-Ausgaben hinzufügen
echo "🔄 DEBUGPY-Value: '$DEBUGPY'"
echo "🔄 FLASK_DEBUG-Value: '$FLASK_DEBUG'"

# Debug-Modus aktivieren, wenn eine der Variablen gesetzt ist
if [[ "$DEBUGPY" == "1" || "$FLASK_DEBUG" == "1" ]]; then
  echo "🔄 Starting in DEBUG mode (Port 5678)..."
  exec python -m debugpy --listen 0.0.0.0:5678 -m flask run --host=0.0.0.0 --port=5000
else
  echo "🚀 Starting in PRODUCTION mode..."
  exec gunicorn -b 0.0.0.0:5000 app:app
fi


SCRIPT_END

chmod +x entrypoint.sh


# create translate.sh and run it
cat <<'SCRIPT_END' > ../translate.sh
#!/bin/bash
set -e

APP_DIR="steam-gift-manager"
TRANSLATION_DIR="$APP_DIR/translations"
LANGS=("de" "en")

# Prüfe jq
if ! command -v jq &>/dev/null; then
  echo "❌ jq is required. Install with: sudo apt-get install jq"
  exit 1
fi

echo -e "\n\033[1;32m✅ Extracting translations...\033[0m"

# 1. create json files
mkdir -p "$TRANSLATION_DIR"
for lang in "${LANGS[@]}"; do
  file="$TRANSLATION_DIR/$lang.json"
  [ -f "$file" ] || echo "{}" > "$file"
done

# 2. extract all strings
STRINGS=$(grep -rhoP "_\(\s*['\"]((?:[^']|'[^'])*?)['\"]\s*[,)]" \
  "$APP_DIR/templates" "$APP_DIR/app.py" | \
  sed -E "s/_\(\s*['\"](.+?)['\"]\s*[,)]/\1/" | sort | uniq)

# 3. put da keys in da json
for lang in "${LANGS[@]}"; do
  file="$TRANSLATION_DIR/$lang.json"
  tmp="$file.tmp"
  jq --argjson keys "$(echo "$STRINGS" | jq -R . | jq -s .)" \
    'reduce $keys[] as $k (.; .[$k] = (.[$k] // ""))' "$file" > "$tmp"
  mv "$tmp" "$file"
done

echo -e "\n\033[1;32m✅ Done! Translation keys added.\033[0m"

SCRIPT_END

chmod +x ../translate.sh


# SOFORT AUSFÜHREN, um Basis-JSONs zu erstellen
cd ..
./translate.sh
cd $PROJECT_DIR

# 5. Dockerfile
cat <<'DOCKER_END' > Dockerfile
FROM python:3.10-slim

SHELL ["/bin/bash", "-c"]

RUN apt-get update && apt-get install -y --no-install-recommends \
    curl \
    wget \
    && mkdir -p /app/static \
    && wget -O /app/static/logo.webp "https://drop.nocadmin.net/logo.webp" \
    && wget -O /app/static/logo_small.webp "https://drop.nocadmin.net/logo_small.webp" \
    && wget -O /app/static/forgejo.webp "https://drop.nocadmin.net/forgejo.webp" \
    && wget -O /app/static/gog_logo.webp "https://drop.nocadmin.net/gog_logo.webp" \
    && wget -O /app/static/logo_small_maskable.webp  "https://drop.nocadmin.net/logo_small_maskable.webp" \
    && rm -rf /var/lib/apt/lists/*

RUN apt-get update && apt-get install -y locales && \
    sed -i '/de_DE.UTF-8/s/^# //' /etc/locale.gen && \
    locale-gen
ENV LC_ALL=de_DE.UTF-8 LANG=de_DE.UTF-8


RUN mkdir -p /app/data && \
    chown -R 1000:1000 /app/data 

ENV TZ=${TZ}
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone

COPY entrypoint.sh /app/entrypoint.sh
RUN chmod +x /app/entrypoint.sh

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

ARG UID=1000
ARG GID=1000

RUN groupadd -g ${GID} appuser && \
    useradd -l -o -u ${UID} -g appuser -m appuser && \
    mkdir -p /app && \
    chown -R appuser:appuser /app

USER appuser

EXPOSE 5000 5678
ENTRYPOINT ["/app/entrypoint.sh"]

DOCKER_END

# 6. docker-compose.yml
cat <<COMPOSE_END > docker-compose.yml
services:
  redis:
    image: redis:alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    networks:
      - app-network

  steam-manager:
    build:
      context: .
      args:
        - UID=${UID:-1000}
        - GID=${GID:-1000}
    ports:
      - "5000:5000"
      - "5678:5678"
    env_file:
      - .env
    environment:
      - REDIS_URL=redis://redis:6379/0
    volumes:
      - ../data:/app/data 
      - ./translations:/app/translations:rw
    user: "${UID:-1000}:${GID:-1000}"
    restart: unless-stopped
    command: ["/app/entrypoint.sh"]
    networks:
      - app-network
    depends_on:
      - redis

volumes:
  redis_data:

networks:
  app-network:
    driver: bridge



COMPOSE_END



cat <<'SCRIPT_END' > ../upgrade.sh
#!/bin/bash
set -e

# Set the working directory to the project directory
cd "$(dirname "$0")/steam-gift-manager"

# Setze FLASK_APP, falls nötig
export FLASK_APP=app.py

# Initialize migrations, if not yet available
if [ ! -d migrations ]; then
  echo "Starting Flask-Migrate..."
  docker-compose exec steam-manager flask db init
fi

# Create migration (only if models have changed)
docker-compose exec steam-manager flask db migrate -m "Automatic Migration"

# Apply migration
docker-compose exec steam-manager flask db upgrade

echo "✅ Database migration completed!"
SCRIPT_END
chmod +x ../upgrade.sh

# Manifest for PWA
cat <<MANIFEST_END > static/manifest.json
{
  "id": "/",
  "name": "Game Key Manager",
  "short_name": "GameKeys",
  "start_url": "/",
  "display": "standalone",
  "background_color": "#212529",
  "theme_color": "#212529",
  "description": "Manage Steam/GOG keys easily!",
  "orientation": "any",
  "launch_handler": {
    "client_mode": "navigate-existing"
  },
  "icons": [
    {
      "src": "/static/logo_small.webp",
      "sizes": "192x192",
      "type": "image/webp",
      "purpose": "any"
    },
    {
      "src": "/static/logo_small_maskable.webp",
      "sizes": "192x192",
      "type": "image/webp",
      "purpose": "maskable"
    },
    {
      "src": "/static/logo.webp",
      "sizes": "512x512",
      "type": "image/webp",
      "purpose": "any maskable"
    }
  ]
}
MANIFEST_END


# Service Worker
cat <<SW_END > static/serviceworker.js
const CACHE_NAME = 'game-key-manager-v2';
const ASSETS = [
  '/',
  '/static/style.css',
  '/static/logo.webp',
  '/static/logo_small.webp',
  '/static/gog_logo.webp',
  '/static/forgejo.webp'
];

self.addEventListener('install', (event) => {
  event.waitUntil(
    caches.open(CACHE_NAME)
      .then(cache => cache.addAll(ASSETS))
  );
});

self.addEventListener('fetch', (event) => {
  event.respondWith(
    caches.match(event.request)
      .then(cachedResponse => cachedResponse || fetch(event.request))
  );
});

self.addEventListener('activate', (event) => {
  event.waitUntil(
    caches.keys().then(keys => Promise.all(
      keys.filter(key => key !== CACHE_NAME)
        .map(key => caches.delete(key))
    ))
  );
});
SW_END

echo -e "\n\033[1;32m✅ Setup done! Seems to be okay!\033[0m"
echo -e "Have a look in your .env"
echo -e "nano .env"
echo -e "\n\033[1;32m✅ After you are done start the system with:\033[0m"
echo -e "cd steam-gift-manager"
echo -e "docker-compose build --no-cache && docker-compose up -d"
echo -e "\n${GREEN}✅ JSON-based translations!${NC}"
echo -e "you can edit them here:"
echo -e "  - translations/de.json"
echo -e "  - translations/en.json"
echo -e "Enter your Apprise URLs in .env at APPRISE_URLS (e.g. for Pushover, Gotify, Matrix etc.)"
echo -e "You can put your IsThereAnyDeal API Key in there, too"
echo -e "\nAfter any change in you configuration, .env or even translations:"
echo -e "cd steam-gift-manager"
echo -e "docker-compose down && docker-compose up -d --build"
echo -e "\n\033[1;32m❗ Great - if you are updating/upgrading - visit my git for more details ❗\033[0m"