app.py

#!/usr/bin/env python3
"""
Centralized Artifact Repository Manager
A comprehensive single source of truth for all internal and third-party:
- Binaries and executables
- Software components and libraries  
- Packages (Docker, APT, NPM, Python, etc.)
- AI/ML models and datasets
- Development tools and artifacts
"""

import os
import json
import hashlib
import mimetypes
import uuid
from datetime import datetime, timedelta, timezone
from typing import Dict, List, Optional, Any
from pathlib import Path
import tempfile
import shutil
import subprocess
try:
    import magic
except ImportError:
    magic = None
import yaml
from sqlalchemy import or_

from flask import Flask, request, jsonify, send_file, render_template, abort, make_response
from flask_sqlalchemy import SQLAlchemy
from flask_jwt_extended import JWTManager, create_access_token, jwt_required, get_jwt_identity
from flask_cors import CORS
from werkzeug.security import generate_password_hash, check_password_hash
from werkzeug.utils import secure_filename
from werkzeug.middleware.proxy_fix import ProxyFix
from sqlalchemy import desc, func, and_, or_
import uuid
from dotenv import load_dotenv
import logging

# Load environment variables
load_dotenv()

# Initialize Flask app
app = Flask(__name__)

# Configure for reverse proxy (Cloudflare Tunnel)
app.wsgi_app = ProxyFix(app.wsgi_app, x_for=1, x_proto=1, x_host=1, x_prefix=1)

app.config['SECRET_KEY'] = os.getenv('SECRET_KEY', 'dev-key-change-in-production')
app.config['SQLALCHEMY_DATABASE_URI'] = os.getenv('DATABASE_URL', 'sqlite:///artifact_registry.db')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['JWT_SECRET_KEY'] = os.getenv('JWT_SECRET_KEY', 'jwt-secret-change-in-production')
app.config['JWT_ACCESS_TOKEN_EXPIRES'] = timedelta(hours=24)
app.config['UPLOAD_FOLDER'] = os.getenv('UPLOAD_FOLDER', './storage')
app.config['STORAGE_PATH'] = os.getenv('STORAGE_PATH', './storage')
app.config['EXTERNAL_URL'] = os.getenv('EXTERNAL_URL', 'http://localhost:5001')
app.config['MAX_CONTENT_LENGTH'] = 50 * 1024 * 1024 * 1024  # 50GB max file size

# Initialize extensions
db = SQLAlchemy(app)
jwt = JWTManager(app)
CORS(app)

# JWT Error Handlers
@jwt.expired_token_loader
def expired_token_callback(jwt_header, jwt_payload):
    print(f"DEBUG JWT: Expired token - header: {jwt_header}, payload: {jwt_payload}")
    return jsonify({'error': 'Token has expired'}), 401

@jwt.invalid_token_loader
def invalid_token_callback(error):
    print(f"DEBUG JWT: Invalid token - error: {error}")
    return jsonify({'error': f'Invalid token: {error}'}), 401

@jwt.unauthorized_loader
def missing_token_callback(error):
    print(f"DEBUG JWT: Missing token - error: {error}")
    return jsonify({'error': f'Authorization token required: {error}'}), 401

@jwt.needs_fresh_token_loader
def token_not_fresh_callback(jwt_header, jwt_payload):
    print(f"DEBUG JWT: Token not fresh - header: {jwt_header}, payload: {jwt_payload}")
    return jsonify({'error': 'Fresh token required'}), 401

@jwt.revoked_token_loader
def revoked_token_callback(jwt_header, jwt_payload):
    print(f"DEBUG JWT: Revoked token - header: {jwt_header}, payload: {jwt_payload}")
    return jsonify({'error': 'Token has been revoked'}), 401

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Ensure upload directory exists
os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)

# Supported artifact types with their configurations
ARTIFACT_TYPES = {
    'docker': {
        'name': 'Docker Images',
        'extensions': ['.tar', '.tar.gz', '.tar.xz'],
        'mime_types': ['application/x-tar', 'application/gzip'],
        'storage_path': 'docker',
        'api_prefix': '/v2'
    },
    'apt': {
        'name': 'APT Packages',
        'extensions': ['.deb'],
        'mime_types': ['application/x-debian-package'],
        'storage_path': 'apt',
        'api_prefix': '/apt'
    },
    'npm': {
        'name': 'NPM Packages',
        'extensions': ['.tgz', '.tar.gz'],
        'mime_types': ['application/gzip'],
        'storage_path': 'npm',
        'api_prefix': '/npm'
    },
    'python': {
        'name': 'Python Packages',
        'extensions': ['.whl', '.tar.gz', '.zip'],
        'mime_types': ['application/zip', 'application/gzip'],
        'storage_path': 'python',
        'api_prefix': '/pypi'
    },
    'maven': {
        'name': 'Maven Artifacts',
        'extensions': ['.jar', '.war', '.ear', '.pom'],
        'mime_types': ['application/java-archive', 'application/xml'],
        'storage_path': 'maven',
        'api_prefix': '/maven'
    },
    'nuget': {
        'name': 'NuGet Packages',
        'extensions': ['.nupkg'],
        'mime_types': ['application/zip'],
        'storage_path': 'nuget',
        'api_prefix': '/nuget'
    },
    'helm': {
        'name': 'Helm Charts',
        'extensions': ['.tgz'],
        'mime_types': ['application/gzip'],
        'storage_path': 'helm',
        'api_prefix': '/helm'
    },
    'generic': {
        'name': 'Generic Binaries',
        'extensions': ['.bin', '.exe', '.dmg', '.msi', '.appimage'],
        'mime_types': ['application/octet-stream', 'application/x-executable'],
        'storage_path': 'generic',
        'api_prefix': '/generic'
    },
    'ai-model': {
        'name': 'AI/ML Models',
        'extensions': ['.pkl', '.h5', '.pb', '.onnx', '.pt', '.pth', '.safetensors'],
        'mime_types': ['application/octet-stream'],
        'storage_path': 'models',
        'api_prefix': '/models'
    },
    'dataset': {
        'name': 'Datasets',
        'extensions': ['.csv', '.json', '.parquet', '.h5', '.zarr'],
        'mime_types': ['text/csv', 'application/json', 'application/octet-stream'],
        'storage_path': 'datasets',
        'api_prefix': '/datasets'
    },
    'firmware': {
        'name': 'Firmware & BIOS',
        'extensions': ['.bin', '.hex', '.fw', '.rom'],
        'mime_types': ['application/octet-stream'],
        'storage_path': 'firmware',
        'api_prefix': '/firmware'
    },
    'documentation': {
        'name': 'Documentation',
        'extensions': ['.pdf', '.md', '.html', '.zip'],
        'mime_types': ['application/pdf', 'text/markdown', 'text/html', 'application/zip'],
        'storage_path': 'docs',
        'api_prefix': '/docs'
    }
}

# Database Models
class User(db.Model):
    __tablename__ = 'users'
    
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    password_hash = db.Column(db.String(255), nullable=False)
    role = db.Column(db.String(20), default='user')  # admin, user, readonly
    is_active = db.Column(db.Boolean, default=True)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    last_login = db.Column(db.DateTime)
    
    # Relationships
    artifacts = db.relationship('Artifact', backref='owner', lazy=True)
    downloads = db.relationship('Download', backref='user', lazy=True)
    
    def check_password(self, password):
        """Check if the provided password matches the user's password hash"""
        return check_password_hash(self.password_hash, password)
    
    def set_password(self, password):
        """Set the user's password hash"""
        self.password_hash = generate_password_hash(password)

class Organization(db.Model):
    __tablename__ = 'organizations'
    
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100), unique=True, nullable=False)
    display_name = db.Column(db.String(200))
    description = db.Column(db.Text)
    is_public = db.Column(db.Boolean, default=False)
    created_by = db.Column(db.String(100), nullable=False)  # Username who created the org
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    
    # Relationships
    repositories = db.relationship('Repository', backref='organization', lazy=True)

class Repository(db.Model):
    __tablename__ = 'repositories'
    
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100), nullable=False)
    display_name = db.Column(db.String(200))
    description = db.Column(db.Text)
    artifact_type = db.Column(db.String(50), nullable=False)
    is_public = db.Column(db.Boolean, default=False)
    org_id = db.Column(db.Integer, db.ForeignKey('organizations.id'))
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    
    # Relationships
    artifacts = db.relationship('Artifact', backref='repository', lazy=True)
    
    @property
    def package_type(self):
        """Alias for artifact_type to maintain compatibility"""
        return self.artifact_type
    
    __table_args__ = (db.UniqueConstraint('name', 'org_id', name='_repo_org_uc'),)

class Artifact(db.Model):
    __tablename__ = 'artifacts'
    
    id = db.Column(db.Integer, primary_key=True)
    uuid = db.Column(db.String(36), unique=True, default=lambda: str(uuid.uuid4()))
    name = db.Column(db.String(200), nullable=False)
    version = db.Column(db.String(100), nullable=False)
    artifact_type = db.Column(db.String(50), nullable=False)
    description = db.Column(db.Text)
    tags = db.Column(db.JSON)
    labels = db.Column(db.JSON)
    
    # File information
    filename = db.Column(db.String(255), nullable=False)
    file_path = db.Column(db.String(500), nullable=False)
    file_size = db.Column(db.BigInteger, nullable=False)
    file_hash_sha256 = db.Column(db.String(64), nullable=False)
    file_hash_md5 = db.Column(db.String(32))
    mime_type = db.Column(db.String(100))
    
    # Metadata
    artifact_metadata = db.Column(db.JSON)
    scan_results = db.Column(db.JSON)
    vulnerability_scan = db.Column(db.JSON)
    
    # Relationships
    owner_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
    repo_id = db.Column(db.Integer, db.ForeignKey('repositories.id'))
    
    # Timestamps
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    last_accessed = db.Column(db.DateTime)
    
    # Relationships
    downloads = db.relationship('Download', backref='artifact', lazy=True)
    dependencies = db.relationship('ArtifactDependency', 
                                 foreign_keys='ArtifactDependency.artifact_id',
                                 backref='artifact', lazy=True)
    
    __table_args__ = (db.UniqueConstraint('name', 'version', 'repo_id', name='_artifact_version_uc'),)

class ArtifactDependency(db.Model):
    __tablename__ = 'artifact_dependencies'
    
    id = db.Column(db.Integer, primary_key=True)
    artifact_id = db.Column(db.Integer, db.ForeignKey('artifacts.id'), nullable=False)
    dependency_id = db.Column(db.Integer, db.ForeignKey('artifacts.id'))
    dependency_name = db.Column(db.String(200))
    dependency_version = db.Column(db.String(100))
    dependency_type = db.Column(db.String(50))
    is_required = db.Column(db.Boolean, default=True)

class Download(db.Model):
    __tablename__ = 'downloads'
    
    id = db.Column(db.Integer, primary_key=True)
    artifact_id = db.Column(db.Integer, db.ForeignKey('artifacts.id'), nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
    ip_address = db.Column(db.String(45))
    user_agent = db.Column(db.String(500))
    downloaded_at = db.Column(db.DateTime, default=datetime.utcnow)

class ApiKey(db.Model):
    __tablename__ = 'api_keys'
    
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100), nullable=False)
    key_hash = db.Column(db.String(255), nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
    permissions = db.Column(db.JSON)
    is_active = db.Column(db.Boolean, default=True)
    expires_at = db.Column(db.DateTime)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    last_used = db.Column(db.DateTime)

# Utility functions
def calculate_file_hash(file_path: str, algorithm: str = 'sha256') -> str:
    """Calculate file hash using specified algorithm."""
    hash_obj = hashlib.new(algorithm)
    with open(file_path, 'rb') as f:
        for chunk in iter(lambda: f.read(4096), b""):
            hash_obj.update(chunk)
    return hash_obj.hexdigest()

def detect_file_type(file_path: str) -> str:
    """Detect file type using python-magic if available."""
    if magic:
        try:
            return magic.from_file(file_path, mime=True)
        except:
            pass
    return mimetypes.guess_type(file_path)[0] or 'application/octet-stream'

def validate_artifact_type(artifact_type: str) -> bool:
    """Validate if artifact type is supported."""
    return artifact_type in ARTIFACT_TYPES

def get_storage_path(artifact_type: str, org_name: str, repo_name: str, artifact_name: str) -> str:
    """Generate storage path for artifact."""
    base_path = ARTIFACT_TYPES[artifact_type]['storage_path']
    return os.path.join(app.config['UPLOAD_FOLDER'], base_path, org_name, repo_name, artifact_name)

# Authentication helpers
def authenticate_user(username: str, password: str) -> Optional[User]:
    """Authenticate user with username and password."""
    user = User.query.filter_by(username=username, is_active=True).first()
    if user and check_password_hash(user.password_hash, password):
        user.last_login = datetime.now(timezone.utc)
        db.session.commit()
        return user
    return None

# Routes
@app.route('/')
def index():
    """Main dashboard page."""
    return render_template('index.html')

@app.route('/api/health')
def health_check():
    """Health check endpoint."""
    return jsonify({
        'status': 'healthy',
        'timestamp': datetime.utcnow().isoformat(),
        'version': '1.0.0'
    })

@app.route('/api/info')
def system_info():
    """System information endpoint."""
    return jsonify({
        'name': 'Centralized Artifact Repository Manager',
        'version': '1.0.0',
        'supported_types': list(ARTIFACT_TYPES.keys()),
        'artifact_types': {
            k: {'name': v['name'], 'api_prefix': v['api_prefix']} 
            for k, v in ARTIFACT_TYPES.items()
        }
    })

# Authentication endpoints
@app.route('/api/auth/login', methods=['POST'])
def login():
    """User login endpoint."""
    data = request.get_json()
    username = data.get('username')
    password = data.get('password')
    
    if not username or not password:
        return jsonify({'error': 'Username and password required'}), 400
    
    user = authenticate_user(username, password)
    if not user:
        return jsonify({'error': 'Invalid credentials'}), 401
    
    access_token = create_access_token(identity=user.username)
    return jsonify({
        'access_token': access_token,
        'user': {
            'id': user.id,
            'username': user.username,
            'email': user.email,
            'role': user.role
        }
    })

@app.route('/api/auth/register', methods=['POST'])
def register():
    """User registration endpoint."""
    data = request.get_json()
    username = data.get('username')
    email = data.get('email')
    password = data.get('password')
    
    if not all([username, email, password]):
        return jsonify({'error': 'Username, email, and password required'}), 400
    
    if User.query.filter_by(username=username).first():
        return jsonify({'error': 'Username already exists'}), 409
    
    if User.query.filter_by(email=email).first():
        return jsonify({'error': 'Email already exists'}), 409
    
    user = User(
        username=username,
        email=email,
        password_hash=generate_password_hash(password)
    )
    db.session.add(user)
    db.session.commit()
    
    return jsonify({'message': 'User created successfully'}), 201

@app.route('/api/users/me')
@jwt_required()
def get_current_user():
    """Get current user information."""
    user_id = get_jwt_identity()
    user = User.query.get(user_id)
    
    return jsonify({
        'id': user.id,
        'username': user.username,
        'email': user.email,
        'role': user.role,
        'created_at': user.created_at.isoformat(),
        'last_login': user.last_login.isoformat() if user.last_login else None
    })

# Organization endpoints
@app.route('/api/organizations', methods=['GET'])
def get_organizations():
    """Get all organizations - public endpoint."""
    organizations = Organization.query.all()
    return jsonify([{
        'id': org.id,
        'name': org.name,
        'description': org.description,
        'created_at': org.created_at.isoformat()
    } for org in organizations])

@app.route('/api/organizations', methods=['POST'])
@jwt_required()
def create_organization():
    """Create a new organization."""
    current_user = get_jwt_identity()
    data = request.get_json()
    
    if not data or not data.get('name'):
        return jsonify({'error': 'Organization name is required'}), 400
    
    # Check if organization already exists
    existing_org = Organization.query.filter_by(name=data['name']).first()
    if existing_org:
        return jsonify({'error': 'Organization already exists'}), 409
    
    # Handle visibility - convert from 'public'/'private' to boolean
    is_public = data.get('visibility', 'private') == 'public'
    
    try:
        organization = Organization(
            name=data['name'],
            description=data.get('description', ''),
            is_public=is_public,
            created_by=current_user
        )
        
        db.session.add(organization)
        db.session.commit()
        
        return jsonify({
            'id': organization.id,
            'name': organization.name,
            'description': organization.description,
            'is_public': organization.is_public,
            'created_by': organization.created_by,
            'created_at': organization.created_at.isoformat()
        }), 201
        
    except Exception as e:
        db.session.rollback()
        return jsonify({'error': f'Database error: {str(e)}'}), 422

@app.route('/api/organizations/<org_name>/repositories', methods=['GET'])
def get_repositories(org_name):
    """Get repositories for an organization."""
    organization = Organization.query.filter_by(name=org_name).first()
    if not organization:
        return jsonify({'error': 'Organization not found'}), 404
    
    repositories = Repository.query.filter_by(org_id=organization.id).all()
    return jsonify([{
        'id': repo.id,
        'name': repo.name,
        'description': repo.description,
        'package_type': repo.artifact_type,
        'visibility': 'public' if repo.is_public else 'private',
        'created_at': repo.created_at.isoformat()
    } for repo in repositories])

@app.route('/api/organizations/<org_name>/repositories', methods=['POST'])
@jwt_required()
def create_repository(org_name):
    """Create a new repository in an organization."""
    try:
        current_user = get_jwt_identity()
        print(f"DEBUG REPO: JWT identity retrieved successfully: {current_user}")
    except Exception as e:
        print(f"DEBUG REPO: Error getting JWT identity: {str(e)}")
        return jsonify({'error': f'JWT error: {str(e)}'}), 401
    
    data = request.get_json()
    
    print(f"DEBUG REPO: Create repository data: {data}")
    print(f"DEBUG REPO: Current user: {current_user}")
    print(f"DEBUG REPO: Organization name: {org_name}")
    
    if not data or not data.get('name') or not data.get('package_type'):
        print("DEBUG REPO: Missing repository name or package_type")
        return jsonify({'error': 'Repository name and package type are required'}), 400
    
    # Find organization
    organization = Organization.query.filter_by(name=org_name).first()
    if not organization:
        print(f"DEBUG REPO: Organization {org_name} not found")
        return jsonify({'error': 'Organization not found'}), 404
    
    # Check if repository already exists
    existing_repo = Repository.query.filter_by(name=data['name'], org_id=organization.id).first()
    if existing_repo:
        print(f"DEBUG REPO: Repository {data['name']} already exists in {org_name}")
        return jsonify({'error': 'Repository already exists in this organization'}), 409
    
    try:
        repository = Repository(
            name=data['name'],
            display_name=data.get('display_name', data['name']),
            description=data.get('description', ''),
            artifact_type=data['package_type'],
            org_id=organization.id,
            is_public=data.get('visibility', 'private') == 'public'
        )
        
        db.session.add(repository)
        db.session.commit()
        
        print(f"DEBUG REPO: Repository {data['name']} created successfully")
        
        return jsonify({
            'id': repository.id,
            'name': repository.name,
            'description': repository.description,
            'package_type': repository.artifact_type,
            'visibility': 'public' if repository.is_public else 'private',
            'created_at': repository.created_at.isoformat()
        }), 201
        
    except Exception as e:
        print(f"DEBUG REPO: Error creating repository: {str(e)}")
        db.session.rollback()
        return jsonify({'error': f'Database error: {str(e)}'}), 422

# Search endpoint
@app.route('/api/search', methods=['GET'])
def search():
    """Search for artifacts, organizations, or repositories."""
    query = request.args.get('q', '')
    search_type = request.args.get('type', 'all')
    limit = min(int(request.args.get('limit', 50)), 100)
    
    results = {'results': []}
    
    if search_type in ['all', 'artifact']:
        artifacts = Artifact.query
        if query:
            artifacts = artifacts.filter(Artifact.name.contains(query))
        artifacts = artifacts.limit(limit).all()
        
        results['results'].extend([{
            'type': 'artifact',
            'id': artifact.id,
            'name': artifact.name,
            'version': artifact.version,
            'package_type': artifact.package_type,
            'size': artifact.file_size,
            'created_at': artifact.created_at.isoformat()
        } for artifact in artifacts])
    
    if search_type in ['all', 'organization']:
        organizations = Organization.query
        if query:
            organizations = organizations.filter(Organization.name.contains(query))
        organizations = organizations.limit(limit).all()
        
        results['results'].extend([{
            'type': 'organization',
            'id': org.id,
            'name': org.name,
            'description': org.description,
            'created_at': org.created_at.isoformat()
        } for org in organizations])
    
    return jsonify(results)

# Statistics and analytics
@app.route('/api/stats')
def statistics():
    """Get repository statistics - public endpoint with basic stats."""
    stats = {
        'total_artifacts': Artifact.query.count(),
        'total_organizations': Organization.query.count(),
        'total_repositories': Repository.query.count(),
        'total_downloads': Download.query.count(),
        'storage_usage': 0,
        'artifact_types': {},
        'recent_uploads': [],
        'top_artifacts': []
    }
    
    # Calculate storage usage
    storage_usage = db.session.query(func.sum(Artifact.file_size)).scalar() or 0
    stats['storage_usage'] = storage_usage
    
    # Artifact types breakdown
    type_counts = db.session.query(
        Artifact.artifact_type,
        func.count(Artifact.id)
    ).group_by(Artifact.artifact_type).all()
    
    stats['artifact_types'] = {
        artifact_type: {
            'count': count,
            'name': ARTIFACT_TYPES.get(artifact_type, {}).get('name', artifact_type)
        }
        for artifact_type, count in type_counts
    }
    
    # Recent uploads
    recent = Artifact.query.order_by(desc(Artifact.created_at)).limit(10).all()
    stats['recent_uploads'] = [{
        'uuid': artifact.uuid,
        'name': artifact.name,
        'version': artifact.version,
        'type': artifact.artifact_type,
        'created_at': artifact.created_at.isoformat(),
        'owner': artifact.owner.username
    } for artifact in recent]
    
    return jsonify(stats)

# Error handlers
@app.errorhandler(404)
def not_found(error):
    return jsonify({'error': 'Not found'}), 404

@app.errorhandler(500)
def internal_error(error):
    db.session.rollback()
    return jsonify({'error': 'Internal server error'}), 500

@app.route('/test')
def test_repo_creation():
    """Test page for repository creation debugging."""
    return render_template('test_repo_creation.html')

# Docker Registry HTTP API V2 Implementation
# https://docs.docker.com/registry/spec/api/

@app.route('/v2/')
def docker_registry_version_check():
    """Docker Registry API version check endpoint"""
    # Check if authentication is provided
    auth_header = request.headers.get('Authorization')
    if not auth_header:
        # Determine the correct realm URL (handle HTTPS proxies)
        external_url = os.getenv('EXTERNAL_URL')
        if external_url:
            realm_url = f"{external_url}/v2/auth"
        else:
            # Fallback to request-based URL construction
            scheme = 'https' if request.headers.get('X-Forwarded-Proto') == 'https' or request.is_secure else 'http'
            host = request.headers.get('X-Forwarded-Host') or request.headers.get('Host') or request.host
            realm_url = f"{scheme}://{host}/v2/auth"
        
        # Return challenge for authentication
        response = make_response('', 401)
        response.headers['WWW-Authenticate'] = f'Bearer realm="{realm_url}",service="registry"'
        response.headers['Docker-Distribution-API-Version'] = 'registry/2.0'
        return response
    
    response = make_response('', 200)
    response.headers['Docker-Distribution-API-Version'] = 'registry/2.0'
    return response

@app.route('/v2/<path:name>/manifests/<reference>', methods=['GET'])
@jwt_required()
def get_manifest(name, reference):
    """Get image manifest"""
    try:
        # Parse org/repo from name
        parts = name.split('/')
        if len(parts) < 2:
            return jsonify({'error': 'Invalid repository name'}), 400
        
        org_name = parts[0]
        repo_name = '/'.join(parts[1:])
        
        # Find the repository
        repo = Repository.query.join(Organization).filter(
            Organization.name == org_name,
            Repository.name == repo_name,
            Repository.artifact_type == 'docker'
        ).first()
        
        if not repo:
            return jsonify({'error': 'Repository not found'}), 404
        
        # Find the artifact (manifest)
        # Handle both tag/name references and digest references
        if reference.startswith('sha256:'):
            # Reference is a digest, search by file hash
            digest_hash = reference.replace('sha256:', '')
            artifact = Artifact.query.filter(
                Artifact.repo_id == repo.id,
                Artifact.file_hash_sha256 == digest_hash
            ).first()
        else:
            # Reference is a tag or name
            artifact = Artifact.query.filter(
                Artifact.repo_id == repo.id,
                or_(Artifact.version == reference, Artifact.name == reference)
            ).first()
        
        if not artifact:
            return jsonify({'error': 'Manifest not found'}), 404
        
        # Return the manifest
        manifest_path = os.path.join(app.config['STORAGE_PATH'], artifact.file_path)
        if os.path.exists(manifest_path):
            with open(manifest_path, 'r') as f:
                manifest_content = f.read()
            
            response = make_response(manifest_content)
            response.headers['Content-Type'] = 'application/vnd.docker.distribution.manifest.v2+json'
            response.headers['Docker-Content-Digest'] = f"sha256:{artifact.file_hash_sha256}"
            return response
        
        return jsonify({'error': 'Manifest file not found'}), 404
        
    except Exception as e:
        logger.error(f"Error getting manifest: {e}")
        return jsonify({'error': 'Internal server error'}), 500

@app.route('/v2/<path:name>/manifests/<reference>', methods=['PUT'])
@jwt_required()
def put_manifest(name, reference):
    """Upload image manifest"""
    try:
        # Parse org/repo from name
        parts = name.split('/')
        if len(parts) < 2:
            return jsonify({'error': 'Invalid repository name'}), 400
        
        org_name = parts[0]
        repo_name = '/'.join(parts[1:])
        
        # Find the repository
        repo = Repository.query.join(Organization).filter(
            Organization.name == org_name,
            Repository.name == repo_name,
            Repository.artifact_type == 'docker'
        ).first()
        
        if not repo:
            return jsonify({'error': 'Repository not found'}), 404
        
        # Get manifest content
        manifest_content = request.get_data()
        if not manifest_content:
            return jsonify({'error': 'Empty manifest'}), 400
        
        # Calculate checksum
        checksum = hashlib.sha256(manifest_content).hexdigest()
        
        # Save manifest
        manifest_dir = os.path.join(app.config['STORAGE_PATH'], 'docker', org_name, repo_name, 'manifests')
        os.makedirs(manifest_dir, exist_ok=True)
        
        manifest_path = os.path.join(manifest_dir, f"{reference}.json")
        with open(manifest_path, 'wb') as f:
            f.write(manifest_content)
        
        # Create or update artifact record
        artifact = Artifact.query.filter(
            Artifact.repo_id == repo.id,
            Artifact.version == reference
        ).first()
        
        if not artifact:
            artifact = Artifact(
                repo_id=repo.id,
                name=f"{repo_name}",
                version=reference,
                filename=f"{reference}.manifest",
                file_path=os.path.relpath(manifest_path, app.config['STORAGE_PATH']),
                file_size=len(manifest_content),
                file_hash_sha256=checksum,
                mime_type='application/vnd.docker.distribution.manifest.v2+json',
                artifact_type='docker',
                owner_id=1  # Assuming admin user has ID 1
            )
            db.session.add(artifact)
        else:
            artifact.file_path = os.path.relpath(manifest_path, app.config['STORAGE_PATH'])
            artifact.file_size = len(manifest_content)
            artifact.file_hash_sha256 = checksum
            artifact.updated_at = datetime.utcnow()
        
        db.session.commit()
        
        response = make_response('', 201)
        response.headers['Location'] = f"/v2/{name}/manifests/{reference}"
        response.headers['Docker-Content-Digest'] = f"sha256:{checksum}"
        return response
        
    except Exception as e:
        logger.error(f"Error uploading manifest: {e}")
        return jsonify({'error': 'Internal server error'}), 500

@app.route('/v2/<path:name>/blobs/<digest>', methods=['GET', 'HEAD'])
@jwt_required()
def get_blob(name, digest):
    """Get image blob (layer) or check if it exists"""
    try:
        # Parse org/repo from name
        parts = name.split('/')
        if len(parts) < 2:
            return jsonify({'error': 'Invalid repository name'}), 400
        
        org_name = parts[0]
        repo_name = '/'.join(parts[1:])
        
        # Find blob file (stored with : replaced by _)
        safe_digest = digest.replace(':', '_')
        blob_path = os.path.join(app.config['STORAGE_PATH'], 'docker', org_name, repo_name, 'blobs', safe_digest)
        
        if os.path.exists(blob_path):
            if request.method == 'HEAD':
                # Return headers only for HEAD request
                file_size = os.path.getsize(blob_path)
                response = make_response('', 200)
                response.headers['Docker-Content-Digest'] = digest
                response.headers['Content-Length'] = str(file_size)
                response.headers['Content-Type'] = 'application/octet-stream'
                return response
            else:
                # Return file content for GET request
                return send_file(blob_path, as_attachment=True)
        
        return jsonify({'error': 'Blob not found'}), 404
        
    except Exception as e:
        logger.error(f"Error getting blob: {e}")
        return jsonify({'error': 'Internal server error'}), 500

@app.route('/v2/<path:name>/blobs/uploads/', methods=['POST'])
@jwt_required()
def initiate_blob_upload(name):
    """Initiate blob upload"""
    try:
        # Parse org/repo from name
        parts = name.split('/')
        if len(parts) < 2:
            return jsonify({'error': 'Invalid repository name'}), 400
        
        org_name = parts[0]
        repo_name = '/'.join(parts[1:])
        
        print(f"DEBUG BLOB POST: Looking for org: {org_name}, repo: {repo_name}")
        
        # Check for blob mount request
        mount_digest = request.args.get('mount')
        from_repo = request.args.get('from', '')
        
        if mount_digest:
            print(f"DEBUG BLOB POST: Mount request for {mount_digest} from {from_repo}")
            # TODO: Implement blob mounting - for now, fall through to regular upload
            # In a full implementation, we would check if the blob exists and can be mounted
        
        # Find or create the organization
        org = Organization.query.filter(Organization.name == org_name).first()
        if not org:
            print(f"DEBUG BLOB POST: Creating organization: {org_name}")
            current_user = get_jwt_identity()
            org = Organization(
                name=org_name,
                display_name=org_name,
                description=f"Auto-created organization for {org_name}",
                created_by=current_user
            )
            db.session.add(org)
            db.session.commit()
        
        # Find or create the repository
        repo = Repository.query.filter(
            Repository.org_id == org.id,
            Repository.name == repo_name,
            Repository.artifact_type == 'docker'
        ).first()
        
        if not repo:
            print(f"DEBUG BLOB POST: Creating repository: {repo_name}")
            repo = Repository(
                name=repo_name,
                org_id=org.id,
                artifact_type='docker',
                description=f"Auto-created Docker repository for {repo_name}",
                is_public=True  # You might want to make this configurable
            )
            db.session.add(repo)
            db.session.commit()
        
        print(f"DEBUG BLOB POST: Using org: {org.name}, repo: {repo.name}")
        
        # Generate upload UUID
        upload_uuid = str(uuid.uuid4())
        
        # Create upload directory
        upload_dir = os.path.join(app.config['STORAGE_PATH'], 'docker', 'uploads')
        os.makedirs(upload_dir, exist_ok=True)
        
        response = make_response('', 202)
        response.headers['Location'] = f"/v2/{name}/blobs/uploads/{upload_uuid}"
        response.headers['Range'] = 'bytes=0-0'
        response.headers['Docker-Upload-UUID'] = upload_uuid
        response.headers['Content-Length'] = '0'
        
        print(f"DEBUG BLOB POST: Upload initiated, UUID: {upload_uuid}")
        return response
        
    except Exception as e:
        logger.error(f"Error initiating blob upload: {e}")
        return jsonify({'error': 'Internal server error'}), 500

@app.route('/v2/<path:name>/blobs/uploads/<upload_uuid>', methods=['PATCH'])
@jwt_required()
def upload_blob_chunk(name, upload_uuid):
    """Upload blob chunk"""
    try:
        # Get the uploaded chunk
        chunk_data = request.get_data()
        content_range = request.headers.get('Content-Range', '')
        content_length = int(request.headers.get('Content-Length', 0))
        
        print(f"DEBUG BLOB PATCH: Uploading chunk for {name}, UUID: {upload_uuid}")
        print(f"DEBUG BLOB PATCH: Chunk size: {len(chunk_data)} bytes")
        print(f"DEBUG BLOB PATCH: Content-Length header: {content_length}")
        print(f"DEBUG BLOB PATCH: Content-Type: {request.content_type}")
        print(f"DEBUG BLOB PATCH: Content-Range: {content_range}")
        
        # Save chunk to temporary file
        upload_dir = os.path.join(app.config['STORAGE_PATH'], 'docker', 'uploads')
        temp_path = os.path.join(upload_dir, upload_uuid)
        
        # Parse Content-Range header if present
        start_byte = 0
        if content_range:
            # Content-Range: bytes start-end/total
            import re
            match = re.match(r'bytes (\d+)-(\d+)/(\d+|\*)', content_range)
            if match:
                start_byte = int(match.group(1))
                print(f"DEBUG BLOB PATCH: Start byte from Content-Range: {start_byte}")
        
        # Check if file exists and get current size
        current_size = 0
        if os.path.exists(temp_path):
            current_size = os.path.getsize(temp_path)
            print(f"DEBUG BLOB PATCH: Existing file size: {current_size}")
        
        # If this is a fresh upload or retry from beginning, overwrite
        if start_byte == 0 and current_size == 0:
            mode = 'wb'
        elif start_byte == 0 and current_size > 0:
            # Docker is retrying - overwrite the file
            mode = 'wb'
            print(f"DEBUG BLOB PATCH: Docker retry detected - overwriting file")
        else:
            mode = 'ab'
            
        with open(temp_path, mode) as f:
            if start_byte > 0:
                # Seek to the correct position
                f.seek(start_byte)
            f.write(chunk_data)
        
        # Get new size
        new_size = os.path.getsize(temp_path)
        
        print(f"DEBUG BLOB PATCH: Total uploaded so far: {new_size} bytes")
        
        response = make_response('', 202)
        response.headers['Location'] = f"/v2/{name}/blobs/uploads/{upload_uuid}"
        if new_size > 0:
            response.headers['Range'] = f"bytes=0-{new_size-1}"
        else:
            response.headers['Range'] = "bytes=0-0"
        response.headers['Docker-Upload-UUID'] = upload_uuid
        response.headers['Content-Length'] = '0'
        
        print(f"DEBUG BLOB PATCH: Response Range: {response.headers['Range']}")
        
        return response
        
    except Exception as e:
        print(f"DEBUG BLOB PATCH: Error uploading blob chunk: {e}")
        logger.error(f"Error uploading blob chunk: {e}")
        return jsonify({'error': 'Internal server error'}), 500

@app.route('/v2/<path:name>/blobs/uploads/<upload_uuid>', methods=['PUT'])
@jwt_required()
def complete_blob_upload(name, upload_uuid):
    """Complete blob upload"""
    try:
        print(f"DEBUG BLOB PUT: Completing blob upload for {name}, UUID: {upload_uuid}")
        
        # Parse org/repo from name
        parts = name.split('/')
        if len(parts) < 2:
            return jsonify({'error': 'Invalid repository name'}), 400
        
        org_name = parts[0]
        repo_name = '/'.join(parts[1:])
        
        # Get expected digest from query parameter
        expected_digest = request.args.get('digest')
        if not expected_digest:
            print(f"DEBUG BLOB PUT: Missing digest parameter")
            return jsonify({'error': 'Missing digest parameter'}), 400
        
        print(f"DEBUG BLOB PUT: Expected digest: {expected_digest}")
        
        # Get temporary file
        upload_dir = os.path.join(app.config['STORAGE_PATH'], 'docker', 'uploads')
        temp_path = os.path.join(upload_dir, upload_uuid)
        
        if not os.path.exists(temp_path):
            print(f"DEBUG BLOB PUT: Upload file not found: {temp_path}")
            return jsonify({'error': 'Upload not found'}), 404
        
        # Verify digest
        with open(temp_path, 'rb') as f:
            content = f.read()
            calculated_digest = f"sha256:{hashlib.sha256(content).hexdigest()}"
        
        print(f"DEBUG BLOB PUT: Calculated digest: {calculated_digest}")
        
        if calculated_digest != expected_digest:
            print(f"DEBUG BLOB PUT: Digest mismatch!")
            os.remove(temp_path)
            return jsonify({'error': 'Digest mismatch'}), 400
        
        # Move to final location
        blob_dir = os.path.join(app.config['STORAGE_PATH'], 'docker', org_name, repo_name, 'blobs')
        os.makedirs(blob_dir, exist_ok=True)
        
        final_path = os.path.join(blob_dir, expected_digest.replace(':', '_'))
        os.rename(temp_path, final_path)
        
        print(f"DEBUG BLOB PUT: Blob upload completed successfully")
        
        response = make_response('', 201)
        response.headers['Location'] = f"/v2/{name}/blobs/{expected_digest}"
        response.headers['Docker-Content-Digest'] = expected_digest
        return response
        
    except Exception as e:
        logger.error(f"Error completing blob upload: {e}")
        return jsonify({'error': 'Internal server error'}), 500

@app.route('/v2/<path:name>/tags/list', methods=['GET'])
@jwt_required()
def list_tags(name):
    """List repository tags"""
    try:
        # Parse org/repo from name
        parts = name.split('/')
        if len(parts) < 2:
            return jsonify({'error': 'Invalid repository name'}), 400
        
        org_name = parts[0]
        repo_name = '/'.join(parts[1:])
        
        # Find the repository
        repo = Repository.query.join(Organization).filter(
            Organization.name == org_name,
            Repository.name == repo_name,
            Repository.artifact_type == 'docker'
        ).first()
        
        if not repo:
            return jsonify({'error': 'Repository not found'}), 404
        
        # Get all artifacts (tags) for this repository
        artifacts = Artifact.query.filter(Artifact.repo_id == repo.id).all()
        tags = [artifact.version for artifact in artifacts if artifact.version]
        
        return jsonify({
            'name': name,
            'tags': tags
        })
        
    except Exception as e:
        logger.error(f"Error listing tags: {e}")
        return jsonify({'error': 'Internal server error'}), 500

# Generic artifact upload endpoint
@app.route('/api/organizations/<org_name>/repositories/<repo_name>/artifacts', methods=['POST'])
@jwt_required()
def upload_artifact(org_name, repo_name):
    """Upload an artifact to a repository"""
    try:
        # Find the repository
        repo = Repository.query.join(Organization).filter(
            Organization.name == org_name,
            Repository.name == repo_name
        ).first()
        
        if not repo:
            return jsonify({'error': 'Repository not found'}), 404
        
        # Check if file was uploaded
        if 'file' not in request.files:
            return jsonify({'error': 'No file uploaded'}), 400
        
        file = request.files['file']
        if file.filename == '':
            return jsonify({'error': 'No file selected'}), 400
        
        # Get optional metadata
        name = request.form.get('name', file.filename)
        version = request.form.get('version', 'latest')
        description = request.form.get('description', '')
        
        # Validate package type exists in ARTIFACT_TYPES
        if repo.package_type not in ARTIFACT_TYPES:
            return jsonify({'error': f'Unsupported package type: {repo.package_type}'}), 400
        
        # Create storage directory
        storage_dir = os.path.join(
            app.config['STORAGE_PATH'], 
            ARTIFACT_TYPES[repo.package_type]['storage_path'],
            org_name, 
            repo_name
        )
        os.makedirs(storage_dir, exist_ok=True)
        
        # Save file
        filename = f"{name}-{version}" if version != 'latest' else name
        file_path = os.path.join(storage_dir, filename)
        file.save(file_path)
        
        # Calculate file info
        file_size = os.path.getsize(file_path)
        with open(file_path, 'rb') as f:
            file_hash = hashlib.sha256(f.read()).hexdigest()
        
        # Create artifact record
        artifact = Artifact(
            repo_id=repo.id,
            name=name,
            version=version,
            description=description,
            filename=secure_filename(file.filename),
            file_path=os.path.relpath(file_path, app.config['STORAGE_PATH']),
            file_size=file_size,
            file_hash_sha256=file_hash,
            mime_type=file.content_type or 'application/octet-stream',
            artifact_type=repo.package_type,
            owner_id=1  # Assuming admin user has ID 1
        )
        
        # Check if artifact with same name and version already exists
        existing_artifact = Artifact.query.filter_by(
            repo_id=repo.id,
            name=name,
            version=version
        ).first()
        
        if existing_artifact:
            # Update existing artifact
            existing_artifact.description = description
            existing_artifact.filename = secure_filename(file.filename)
            existing_artifact.file_path = os.path.relpath(file_path, app.config['STORAGE_PATH'])
            existing_artifact.file_size = file_size
            existing_artifact.file_hash_sha256 = file_hash
            existing_artifact.mime_type = file.content_type or 'application/octet-stream'
            existing_artifact.updated_at = datetime.utcnow()
            
            db.session.commit()
            
            return jsonify({
                'message': 'Artifact updated successfully',
                'artifact': {
                    'id': existing_artifact.id,
                    'name': existing_artifact.name,
                    'version': existing_artifact.version,
                    'size': existing_artifact.file_size,
                    'checksum': f"sha256:{existing_artifact.file_hash_sha256}"
                }
            }), 200
        else:
            db.session.add(artifact)
            db.session.commit()
            
            return jsonify({
                'message': 'Artifact uploaded successfully',
                'artifact': {
                    'id': artifact.id,
                    'name': artifact.name,
                    'version': artifact.version,
                    'size': artifact.file_size,
                    'checksum': f"sha256:{artifact.file_hash_sha256}"
                }
            }), 201
        
    except Exception as e:
        logger.error(f"Error uploading artifact: {e}")
        return jsonify({'error': 'Failed to upload artifact'}), 500

@app.route('/api/organizations/<org_name>/repositories/<repo_name>/artifacts', methods=['GET'])
@jwt_required()
def list_artifacts(org_name, repo_name):
    """List artifacts in a repository"""
    try:
        # Find the repository
        repo = Repository.query.join(Organization).filter(
            Organization.name == org_name,
            Repository.name == repo_name
        ).first()
        
        if not repo:
            return jsonify({'error': 'Repository not found'}), 404
        
        # Get artifacts
        artifacts = Artifact.query.filter(Artifact.repo_id == repo.id).all()
        
        return jsonify([{
            'id': artifact.id,
            'name': artifact.name,
            'version': artifact.version,
            'description': artifact.description,
            'size': artifact.file_size,
            'checksum': f"sha256:{artifact.file_hash_sha256}",
            'content_type': artifact.mime_type,
            'created_at': artifact.created_at.isoformat(),
            'updated_at': artifact.updated_at.isoformat()
        } for artifact in artifacts])
        
    except Exception as e:
        logger.error(f"Error listing artifacts: {e}")
        return jsonify({'error': 'Failed to list artifacts'}), 500

@app.route('/api/organizations/<org_name>/repositories/<repo_name>/artifacts/<int:artifact_id>', methods=['GET'])
@jwt_required()
def get_artifact(org_name, repo_name, artifact_id):
    """Get artifact details"""
    try:
        # Find the artifact
        artifact = Artifact.query.join(Repository).join(Organization).filter(
            Organization.name == org_name,
            Repository.name == repo_name,
            Artifact.id == artifact_id
        ).first()
        
        if not artifact:
            return jsonify({'error': 'Artifact not found'}), 404
        
        return jsonify({
            'id': artifact.id,
            'name': artifact.name,
            'version': artifact.version,
            'description': artifact.description,
            'size': artifact.file_size,
            'checksum': f"sha256:{artifact.file_hash_sha256}",
            'content_type': artifact.mime_type,
            'created_at': artifact.created_at.isoformat(),
            'updated_at': artifact.updated_at.isoformat()
        })
        
    except Exception as e:
        logger.error(f"Error getting artifact: {e}")
        return jsonify({'error': 'Failed to get artifact'}), 500

@app.route('/api/organizations/<org_name>/repositories/<repo_name>/artifacts/<int:artifact_id>/download')
@jwt_required()
def download_artifact(org_name, repo_name, artifact_id):
    """Download an artifact"""
    try:
        # Find the artifact
        artifact = Artifact.query.join(Repository).join(Organization).filter(
            Organization.name == org_name,
            Repository.name == repo_name,
            Artifact.id == artifact_id
        ).first()
        
        if not artifact:
            return jsonify({'error': 'Artifact not found'}), 404
        
        # Get file path
        file_path = os.path.join(app.config['STORAGE_PATH'], artifact.file_path)
        
        if not os.path.exists(file_path):
            return jsonify({'error': 'Artifact file not found'}), 404
        
        return send_file(
            file_path,
            as_attachment=True,
            download_name=f"{artifact.name}-{artifact.version}",
            mimetype=artifact.content_type
        )
        
    except Exception as e:
        logger.error(f"Error downloading artifact: {e}")
        return jsonify({'error': 'Failed to download artifact'}), 500

# Docker Registry Authentication Flow
@app.route('/v2/auth', methods=['GET'])
def docker_auth():
    """Docker Registry authentication endpoint"""
    # Get auth parameters
    service = request.args.get('service', 'registry')
    scope = request.args.get('scope', '')
    
    # Determine the correct realm URL (handle HTTPS proxies)
    external_url = os.getenv('EXTERNAL_URL')
    if external_url:
        realm_url = f"{external_url}/v2/auth"
    else:
        # Fallback to request-based URL construction
        scheme = 'https' if request.headers.get('X-Forwarded-Proto') == 'https' or request.is_secure else 'http'
        host = request.headers.get('X-Forwarded-Host') or request.headers.get('Host') or request.host
        realm_url = f"{scheme}://{host}/v2/auth"
    
    # Check basic auth
    auth = request.authorization
    if not auth or not auth.username or not auth.password:
        response = make_response('', 401)
        response.headers['WWW-Authenticate'] = f'Bearer realm="{realm_url}",service="{service}",scope="{scope}"'
        return response
    
    try:
        # Validate user credentials
        user = User.query.filter_by(username=auth.username).first()
        if not user or not user.check_password(auth.password):
            response = make_response('', 401)
            response.headers['WWW-Authenticate'] = f'Bearer realm="{realm_url}",service="{service}",scope="{scope}"'
            return response
        
        # Create a token for Docker
        access_token = create_access_token(
            identity=user.username,
            expires_delta=timedelta(hours=24)
        )
        
        # Return token in Docker registry format
        return jsonify({
            'token': access_token,
            'access_token': access_token,
            'expires_in': 86400,
            'issued_at': datetime.utcnow().isoformat() + 'Z'
        })
        
    except Exception as e:
        logger.error(f"Docker auth error: {e}")
        response = make_response('', 401)
        response.headers['WWW-Authenticate'] = f'Bearer realm="{realm_url}",service="{service}",scope="{scope}"'
        return response

# Package Manager Specific Endpoints

@app.route('/npm/<org_name>/<repo_name>')
@app.route('/npm/<org_name>/<repo_name>/')
def npm_registry_root(org_name, repo_name):
    """NPM registry root endpoint"""
    return jsonify({
        'name': f'{org_name}/{repo_name}',
        'description': f'NPM registry for {org_name}/{repo_name}',
        'registry': f'{request.url_root}npm/{org_name}/{repo_name}'
    })

@app.route('/simple/')
@app.route('/simple')
def pypi_simple_root():
    """PyPI Simple API root endpoint"""
    # List all Python packages across all organizations
    try:
        repositories = Repository.query.filter(Repository.artifact_type == 'python').all()
        packages = []
        for repo in repositories:
            artifacts = Artifact.query.filter(Artifact.repo_id == repo.id).all()
            for artifact in artifacts:
                packages.append(artifact.name)
        
        html = '<html><head><title>Simple Index</title></head><body>'
        for package in set(packages):
            html += f'<a href="/simple/{package}/">{package}</a><br>'
        html += '</body></html>'
        
        return html, 200, {'Content-Type': 'text/html'}
        
    except Exception as e:
        logger.error(f"PyPI simple index error: {e}")
        return 'Error loading package index', 500

@app.route('/simple/<package_name>/')
def pypi_simple_package(package_name):
    """PyPI Simple API package endpoint"""
    try:
        artifacts = Artifact.query.filter(
            Artifact.name == package_name,
            Artifact.artifact_type == 'python'
        ).all()
        
        html = f'<html><head><title>Links for {package_name}</title></head><body>'
        html += f'<h1>Links for {package_name}</h1>'
        
        for artifact in artifacts:
            repo = Repository.query.get(artifact.repo_id)
            org = Organization.query.get(repo.org_id)
            download_url = f'/api/organizations/{org.name}/repositories/{repo.name}/artifacts/{artifact.id}/download'
            html += f'<a href="{download_url}">{artifact.filename}</a><br>'
        
        html += '</body></html>'
        
        return html, 200, {'Content-Type': 'text/html'}
        
    except Exception as e:
        logger.error(f"PyPI package endpoint error: {e}")
        return f'Package {package_name} not found', 404

@app.route('/maven2/<org_name>/<repo_name>/')
@app.route('/maven2/<org_name>/<repo_name>/<path:artifact_path>')
def maven_repository(org_name, repo_name, artifact_path=''):
    """Maven repository endpoint"""
    try:
        repo = Repository.query.join(Organization).filter(
            Organization.name == org_name,
            Repository.name == repo_name,
            Repository.artifact_type == 'maven'
        ).first()
        
        if not repo:
            return 'Repository not found', 404
        
        if not artifact_path:
            # Return repository index
            artifacts = Artifact.query.filter(Artifact.repo_id == repo.id).all()
            html = f'<html><head><title>Maven Repository: {org_name}/{repo_name}</title></head><body>'
            html += f'<h1>Maven Repository: {org_name}/{repo_name}</h1>'
            for artifact in artifacts:
                html += f'<a href="{artifact.name}/">{artifact.name}</a><br>'
            html += '</body></html>'
            return html, 200, {'Content-Type': 'text/html'}
        else:
            # Return specific artifact
            artifact = Artifact.query.filter(
                Artifact.repo_id == repo.id,
                Artifact.name.contains(artifact_path.split('/')[0])
            ).first()
            
            if artifact:
                file_path = os.path.join(app.config['STORAGE_PATH'], artifact.file_path)
                if os.path.exists(file_path):
                    return send_file(file_path)
            
            return 'Artifact not found', 404
            
    except Exception as e:
        logger.error(f"Maven repository error: {e}")
        return 'Internal server error', 500

@app.route('/nuget/<org_name>/<repo_name>')
@app.route('/nuget/<org_name>/<repo_name>/')
def nuget_service_index(org_name, repo_name):
    """NuGet service index endpoint"""
    service_index = {
        "version": "3.0.0",
        "resources": [
            {
                "@id": f"{request.url_root}nuget/{org_name}/{repo_name}/download",
                "@type": "PackageBaseAddress/3.0.0"
            },
            {
                "@id": f"{request.url_root}nuget/{org_name}/{repo_name}/search",
                "@type": "SearchQueryService"
            }
        ]
    }
    return jsonify(service_index)

@app.route('/helm/<org_name>/<repo_name>')
@app.route('/helm/<org_name>/<repo_name>/')
def helm_repository_index(org_name, repo_name):
    """Helm repository index endpoint"""
    try:
        repo = Repository.query.join(Organization).filter(
            Organization.name == org_name,
            Repository.name == repo_name,
            Repository.artifact_type == 'helm'
        ).first()
        
        if not repo:
            return jsonify({'error': 'Repository not found'}), 404
        
        artifacts = Artifact.query.filter(Artifact.repo_id == repo.id).all()
        
        index = {
            "apiVersion": "v1",
            "entries": {},
            "generated": datetime.utcnow().isoformat() + "Z"
        }
        
        for artifact in artifacts:
            chart_name = artifact.name
            if chart_name not in index["entries"]:
                index["entries"][chart_name] = []
            
            index["entries"][chart_name].append({
                "name": artifact.name,
                "version": artifact.version,
                "description": artifact.description or "",
                "created": artifact.created_at.isoformat() + "Z",
                "urls": [f"/api/organizations/{org_name}/repositories/{repo_name}/artifacts/{artifact.id}/download"]
            })
        
        return jsonify(index)
        
    except Exception as e:
        logger.error(f"Helm repository error: {e}")
        return jsonify({'error': 'Internal server error'}), 500

if __name__ == '__main__':
    # Get configuration from environment
    host = os.getenv('REGISTRY_HOST', '0.0.0.0')
    port = int(os.getenv('REGISTRY_PORT', 5001))
    debug = os.getenv('DEBUG', 'False').lower() == 'true'
    
    print(f"Starting Artifact Repository Manager on {host}:{port}")
    print(f"Debug mode: {debug}")
    if os.getenv('EXTERNAL_URL'):
        print(f"External URL: {os.getenv('EXTERNAL_URL')}")
    
    app.run(host=host, port=port, debug=debug)