from django.db import models
from django.dispatch import receiver
from django.db.models.signals import pre_delete

class GlobalCollection(models.Model):
    """全局收藏表（所有应用共享）"""
    UPLOAD_SOURCE_CHOICES = [
        ('local', '本地上传'),
        ('project', '项目收藏'),
        ('third_party', '第三方平台')
    ]
    
    file_identifier = models.CharField(max_length=255, unique=True, verbose_name="文件唯一标识")
    source_platform = models.CharField(max_length=50, choices=UPLOAD_SOURCE_CHOICES)
    original_url = models.URLField(null=True, blank=True, verbose_name="原始链接")
    created_at = models.DateTimeField(auto_now_add=True)
    meta_data = models.JSONField(default=dict, verbose_name="元数据")

    class Meta:
        db_table = 'global_collection'
        verbose_name = '全局收藏'

class AppSpecificStorage(models.Model):
    """应用私有存储表（每个应用独立）"""
    app_name = models.CharField(max_length=50, verbose_name="应用名称")
    global_file = models.ForeignKey(GlobalCollection, on_delete=models.CASCADE)
    local_path = models.FileField(upload_to='app_files/', verbose_name="本地存储路径")
    last_modified = models.DateTimeField(auto_now=True)

    class Meta:
        db_table = 'app_specific_storage'
        unique_together = ('app_name', 'global_file')

class ParameterFile(models.Model):
    """参数文件主表"""
    STATUS_CHOICES = [
        ('active', '生效中'),
        ('deleted', '已删除')
    ]
    
    file_name = models.CharField(max_length=255)
    version = models.PositiveIntegerField(default=1)
    app = models.CharField(max_length=50, verbose_name="所属应用")
    status = models.CharField(max_length=10, choices=STATUS_CHOICES, default='active')
    collection_ref = models.OneToOneField(GlobalCollection, null=True, on_delete=models.SET_NULL)
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        db_table = 'parameter_files'
        indexes = [models.Index(fields=['app', 'status'])]

class ParameterHistory(models.Model):
    """参数删除历史表"""
    original_file = models.ForeignKey(ParameterFile, on_delete=models.CASCADE)
    deleted_at = models.DateTimeField(auto_now_add=True)
    snapshot = models.JSONField(verbose_name="文件快照")

    class Meta:
        db_table = 'parameter_history'

class ThirdPartyPermission(models.Model):
    """第三方平台权限控制表"""
    PERMISSION_LEVELS = [
        ('read', '只读'),
        ('write', '可写入'),
        ('admin', '完全控制')
    ]
    
    app_name = models.CharField(max_length=50)
    platform_name = models.CharField(max_length=50)
    access_token = models.CharField(max_length=255)
    permission_level = models.CharField(max_length=10, choices=PERMISSION_LEVELS)
    expires_at = models.DateTimeField()

    class Meta:
        db_table = 'third_party_permissions'
        unique_together = ('app_name', 'platform_name')

# 信号处理：删除时记录历史
@receiver(pre_delete, sender=ParameterFile)
def create_deletion_history(sender, instance, **kwargs):
    ParameterHistory.objects.create(
        original_file=instance,
        snapshot={
            'file_name': instance.file_name,
            'version': instance.version,
            'app': instance.app
        }
    )

from django.db import models
from django.dispatch import receiver
from django.db.models.signals import pre_delete
from storages.backends.s3boto3 import S3Boto3Storage

# 自定义S3存储路径（按应用隔离）
class AppS3Storage(S3Boto3Storage):
    def __init__(self, app_name=None, **kwargs):
        self.app_name = app_name
        super().__init__(**kwargs)
    
    def get_valid_name(self, name):
        return f"{self.app_name}/{name}"

# 核心文件元数据表（S3文件中心）
class GlobalFileRegistry(models.Model):
    FILE_CATEGORIES = [
        ('param', '参数文件'),
        ('sim', '仿真文件'),
        ('result', '计算结果')
    ]
    
    file_key = models.CharField(max_length=255, unique=True, verbose_name="S3对象键")
    category = models.CharField(max_length=20, choices=FILE_CATEGORIES)
    upload_source = models.CharField(max_length=20)  # 复用原有来源类型
    owner_app = models.CharField(max_length=50, verbose_name="所属应用")
    s3_bucket = models.CharField(max_length=63, default="main-bucket")
    metadata = models.JSONField(default=dict)
    created_at = models.DateTimeField(auto_now_add=True)
    is_public = models.BooleanField(default=False)

    class Meta:
        db_table = 'global_file_registry'
        indexes = [models.Index(fields=['owner_app', 'category'])]

# 跨应用文件引用表
class CrossAppReference(models.Model):
    REFERENCE_TYPES = [
        ('param2sim', '参数->仿真'),
        ('sim2result', '仿真->结果')
    ]
    
    source_file = models.ForeignKey(
        GlobalFileRegistry,
        related_name='outgoing_refs',
        on_delete=models.CASCADE
    )
    target_app = models.CharField(max_length=50)
    target_file = models.ForeignKey(
        GlobalFileRegistry,
        related_name='incoming_refs',
        on_delete=models.CASCADE
    )
    reference_type = models.CharField(max_length=20, choices=REFERENCE_TYPES)
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        db_table = 'cross_app_references'
        unique_together = ('source_file', 'target_file')

# 参数模块专用表
class ParameterFile(models.Model):
    STATUS_CHOICES = [
        ('active', '生效中'),
        ('archived', '已归档')
    ]
    
    global_file = models.OneToOneField(
        GlobalFileRegistry,
        on_delete=models.CASCADE,
        related_name='param_meta'
    )
    version = models.PositiveIntegerField(default=1)
    status = models.CharField(max_length=10, choices=STATUS_CHOICES)
    dependencies = models.ManyToManyField(
        'self',
        symmetrical=False,
        through='ParameterDependency'
    )

    def s3_storage(self):
        return AppS3Storage(app_name="parameters")

    class Meta:
        db_table = 'parameter_files'

# 参数依赖关系表
class ParameterDependency(models.Model):
    parent = models.ForeignKey(
        ParameterFile,
        related_name='child_dependencies',
        on_delete=models.CASCADE
    )
    child = models.ForeignKey(
        ParameterFile,
        related_name='parent_dependencies',
        on_delete=models.CASCADE
    )
    required = models.BooleanField(default=True)

    class Meta:
        db_table = 'parameter_dependencies'

# 仿真模块专用表
class SimulationTask(models.Model):
    global_file = models.ForeignKey(
        GlobalFileRegistry,
        on_delete=models.CASCADE,
        related_name='sim_tasks'
    )
    param_ref = models.ForeignKey(
        ParameterFile,
        null=True,
        on_delete=models.SET_NULL
    )
    status = models.CharField(max_length=20)
    
    def s3_storage(self):
        return AppS3Storage(app_name="simulations")

    class Meta:
        db_table = 'simulation_tasks'

# 信号处理：删除时同步清理S3文件
@receiver(pre_delete, sender=GlobalFileRegistry)
def cleanup_s3_files(sender, instance, **kwargs):
    from django.core.files.storage import default_storage
    try:
        default_storage.delete(instance.file_key)
    except Exception as e:
        logger.error(f"S3删除失败：{instance.file_key} - {str(e)}")

# models.py
from django.db import models
from django.db.models import F
from django.dispatch import receiver
from django.db.models.signals import pre_delete, post_save
from storages.backends.s3boto3 import S3Boto3Storage
import logging

logger = logging.getLogger(__name__)

# ---------------------------
# 自定义S3存储配置
# ---------------------------
class AppAwareS3Storage(S3Boto3Storage):
    """按应用分目录的S3存储"""
    def __init__(self, app_name=None, **kwargs):
        self.app_name = app_name
        super().__init__(**kwargs)
    
    def get_valid_name(self, name):
        if self.app_name:
            return f"{self.app_name}/{name}"
        return name

# ---------------------------
# 核心模型
# ---------------------------
class GlobalFileRegistry(models.Model):
    """全局文件元数据注册中心"""
    FILE_STATES = [
        ('active', '活跃'),
        ('archived', '已归档'),
        ('locked', '锁定')
    ]
    
    file_key = models.CharField(max_length=512, unique=True, verbose_name="S3对象键")
    bucket_name = models.CharField(max_length=63, default="main-bucket")
    reference_count = models.PositiveIntegerField(default=0, verbose_name="引用计数")
    state = models.CharField(max_length=20, choices=FILE_STATES, default='active')
    global_metadata = models.JSONField(default=dict, verbose_name="全局元数据")
    created_at = models.DateTimeField(auto_now_add=True)
    modified_at = models.DateTimeField(auto_now=True)

    class Meta:
        indexes = [
            models.Index(fields=['file_key']),
            models.Index(fields=['state'])
        ]
        verbose_name = "全局文件注册表"

    def __str__(self):
        return f"{self.bucket_name}/{self.file_key}"

    def acquire_reference(self):
        """原子增加引用计数"""
        GlobalFileRegistry.objects.filter(pk=self.pk).update(
            reference_count=F('reference_count') + 1
        )
        self.refresh_from_db()

    def release_reference(self):
        """原子减少引用计数"""
        GlobalFileRegistry.objects.filter(pk=self.pk).update(
            reference_count=F('reference_count') - 1
        )
        self.refresh_from_db()

class AppFileLink(models.Model):
    """应用与文件的关联关系表"""
    app_name = models.CharField(max_length=50, verbose_name="应用名称")
    global_file = models.ForeignKey(
        GlobalFileRegistry,
        on_delete=models.CASCADE,
        related_name='app_links'
    )
    local_metadata = models.JSONField(default=dict, verbose_name="应用私有元数据")
    is_primary = models.BooleanField(default=False, verbose_name="主引用")
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        unique_together = ('app_name', 'global_file')
        verbose_name = "应用文件关联表"

    def save(self, *args, **kwargs):
        """新建关联时更新引用计数"""
        if not self.pk:  # 新建关联
            self.global_file.acquire_reference()
        super().save(*args, **kwargs)

# ---------------------------
# 业务模型示例
# ---------------------------
class ParameterFile(models.Model):
    """参数文件业务表"""
    app_link = models.OneToOneField(
        AppFileLink,
        on_delete=models.CASCADE,
        related_name='parameter_file'
    )
    version = models.PositiveIntegerField(default=1)
    status = models.CharField(max_length=20, default='draft')

    class Meta:
        verbose_name = "参数文件"

    @property
    def storage(self):
        """获取应用专属存储实例"""
        return AppAwareS3Storage(app_name=self.app_link.app_name)

    def get_presigned_url(self, expiration=3600):
        """生成预签名URL"""
        return self.storage.url(
            self.app_link.global_file.file_key,
            parameters={'ExpiresIn': expiration}
        )

class ParameterHistory(models.Model):
    """参数文件操作历史"""
    app_name = models.CharField(max_length=50)
    operation = models.CharField(max_length=20)
    snapshot = models.JSONField()
    timestamp = models.DateTimeField(auto_now_add=True)

    class Meta:
        indexes = [models.Index(fields=['app_name', 'timestamp'])]
        verbose_name = "参数历史记录"

# ---------------------------
# 权限控制模型
# ---------------------------
class ThirdPartyPermission(models.Model):
    """第三方平台访问权限"""
    PERMISSION_CHOICES = [
        ('read', '只读'),
        ('write', '读写'),
        ('admin', '管理')
    ]
    
    app_name = models.CharField(max_length=50)
    platform = models.CharField(max_length=50)
    access_key = models.CharField(max_length=128)
    secret_key = models.CharField(max_length=256)
    permission_level = models.CharField(max_length=10, choices=PERMISSION_CHOICES)
    valid_until = models.DateTimeField()

    class Meta:
        unique_together = ('app_name', 'platform')
        verbose_name = "第三方权限"

# ---------------------------
# 信号处理
# ---------------------------
@receiver(pre_delete, sender=AppFileLink)
def handle_app_link_delete(sender, instance, **kwargs):
    """处理应用关联删除"""
    try:
        # 记录删除操作到历史表
        ParameterHistory.objects.create(
            app_name=instance.app_name,
            operation='delete',
            snapshot={
                'file_key': instance.global_file.file_key,
                'metadata': instance.local_metadata
            }
        )
        
        # 释放引用计数
        instance.global_file.release_reference()
        
        # 检查是否需要物理删除
        if (instance.global_file.reference_count == 0 and 
            instance.global_file.state != 'locked'):
            # 异步删除S3文件（示例使用线程，生产环境应使用Celery）
            from threading import Thread
            def async_delete():
                try:
                    storage = AppAwareS3Storage()
                    storage.delete(instance.global_file.file_key)
                    instance.global_file.delete()
                except Exception as e:
                    logger.error(f"删除失败: {str(e)}")
            Thread(target=async_delete).start()
            
    except Exception as e:
        logger.error(f"删除处理异常: {str(e)}")

@receiver(post_save, sender=GlobalFileRegistry)
def log_file_activity(sender, instance, created, **kwargs):
    """记录全局文件变更"""
    if created:
        action = 'create'
    else:
        action = 'update'
    
    ParameterHistory.objects.create(
        app_name='system',
        operation=action,
        snapshot={
            'file_key': instance.file_key,
            'state': instance.state,
            'references': instance.reference_count
        }
    )

# ---------------------------
# 工具函数
# ---------------------------
def create_app_file(app_name, file_key, metadata=None):
    """创建新的应用文件"""
    global_file = GlobalFileRegistry.objects.create(
        file_key=file_key,
        global_metadata=metadata or {}
    )
    
    link = AppFileLink.objects.create(
        app_name=app_name,
        global_file=global_file,
        local_metadata={'uploader': 'system'}
    )
    
    return link

def transfer_file(source_app, target_app, file_key):
    """跨应用文件流转"""
    try:
        source_link = AppFileLink.objects.get(
            app_name=source_app,
            global_file__file_key=file_key
        )
        
        # 创建新关联
        new_link = AppFileLink.objects.create(
            app_name=target_app,
            global_file=source_link.global_file,
            local_metadata={'source': source_app}
        )
        
        return new_link
    except AppFileLink.DoesNotExist:
        raise ValueError("源文件不存在")

def lock_global_file(file_key):
    """锁定全局文件"""
    file = GlobalFileRegistry.objects.get(file_key=file_key)
    file.state = 'locked'
    file.save()
    return file

new_file = create_app_file(
    app_name='simulation',
    file_key='params/v1/config.json',
    metadata={'author': 'AI'}
)

try:
    transfer_file(
        source_app='simulation',
        target_app='analysis',
        file_key='params/v1/config.json'
    )
except ValueError as e:
    print(f"流转失败: {str(e)}")

# 查找要删除的关联记录
link = AppFileLink.objects.get(app_name='analysis', global_file__file_key='params/v1/config.json')
link.delete()  # 自动触发信号处理

param_file = ParameterFile.objects.get(id=1)
print(param_file.get_presigned_url(expiration=3600))  # 1小时有效期的URL

# views.py
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from .models import GlobalFileRegistry, AppFileLink

class FileUploadAPI(APIView):
    def post(self, request):
        upload_type = request.data.get('type')
        app_name = request.headers.get('X-App-Name')

        if upload_type == 'new':
            # 处理新文件上传
            file = request.FILES.get('file')
            file_key = f"{app_name}/{file.name}"
            
            # 存储到S3（示例代码）
            storage = AppAwareS3Storage(app_name=app_name)
            storage.save(file_key, file)
            
            # 创建数据库记录
            global_file = GlobalFileRegistry.objects.create(
                file_key=file_key,
                bucket_name=storage.bucket_name,
                global_metadata={'size': file.size}
            )
            
            AppFileLink.objects.create(
                app_name=app_name,
                global_file=global_file,
                local_metadata={'upload_type': 'new'}
            )
            
            return Response({'id': global_file.id}, status=status.HTTP_201_CREATED)

        elif upload_type == 'existing':
            # 处理现有文件选择
            file_id = request.data.get('file_id')
            try:
                existing_file = GlobalFileRegistry.objects.get(id=file_id)
                # 验证权限（示例）
                if not existing_file.app_links.filter(app_name=app_name).exists():
                    AppFileLink.objects.create(
                        app_name=app_name,
                        global_file=existing_file,
                        local_metadata={'source': 'existing'}
                    )
                    return Response({'id': existing_file.id})
                return Response({'error': '无权访问该文件'}, status=403)
            except GlobalFileRegistry.DoesNotExist:
                return Response({'error': '文件不存在'}, status=404)

        return Response({'error': '无效的上传类型'}, status=400)

class FileListAPI(APIView):
    def get(self, request):
        app_name = request.headers.get('X-App-Name')
        files = GlobalFileRegistry.objects.filter(
            app_links__app_name=app_name
        ).values('id', 'file_key', 'created_at')
        return Response(list(files))

# models.py
class ExternalPlatform(models.Model):
    name = models.CharField(max_length=50, unique=True)
    bucket_name = models.CharField(max_length=63)
    access_key = models.CharField(max_length=128)
    secret_key = models.CharField(max_length=256)
    region = models.CharField(max_length=50, default='us-east-1')

class ExternalFileReference(models.Model):
    platform = models.ForeignKey(ExternalPlatform, on_delete=models.CASCADE)
    external_file_key = models.CharField(max_length=512)
    internal_file = models.ForeignKey(GlobalFileRegistry, on_delete=models.CASCADE)
    copied_at = models.DateTimeField(auto_now_add=True)

# views.py
from boto3 import client
from django.conf import settings

class ExternalFileAPI(APIView):
    def get(self, request):
        """获取外部平台文件列表"""
        platform_id = request.query_params.get('platform_id')
        try:
            platform = ExternalPlatform.objects.get(id=platform_id)
            s3 = client('s3',
                aws_access_key_id=platform.access_key,
                aws_secret_access_key=platform.secret_key,
                region_name=platform.region
            )
            # 示例：获取前100个文件
            response = s3.list_objects_v2(Bucket=platform.bucket_name, MaxKeys=100)
            files = [{'key': obj['Key'], 'size': obj['Size']} 
                    for obj in response.get('Contents', [])]
            return Response(files)
        except Exception as e:
            return Response({'error': str(e)}, status=500)

    def post(self, request):
        """复制外部文件到本平台"""
        app_name = request.headers.get('X-App-Name')
        platform_id = request.data.get('platform_id')
        external_key = request.data.get('file_key')
        
        try:
            # 获取平台配置
            platform = ExternalPlatform.objects.get(id=platform_id)
            
            # 生成新文件路径
            new_key = f"external/{platform.name}/{external_key.split('/')[-1]}"
            
            # 初始化S3客户端
            source_s3 = client('s3',
                aws_access_key_id=platform.access_key,
                aws_secret_access_key=platform.secret_key,
                region_name=platform.region
            )
            dest_s3 = client('s3',
                aws_access_key_id=settings.AWS_ACCESS_KEY_ID,
                aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY
            )
            
            # 执行复制操作
            copy_source = {'Bucket': platform.bucket_name, 'Key': external_key}
            dest_s3.copy_object(
                CopySource=copy_source,
                Bucket=settings.AWS_STORAGE_BUCKET_NAME,
                Key=new_key
            )
            
            # 创建数据库记录
            global_file = GlobalFileRegistry.objects.create(
                file_key=new_key,
                bucket_name=settings.AWS_STORAGE_BUCKET_NAME,
                global_metadata={'source': 'external'}
            )
            
            ExternalFileReference.objects.create(
                platform=platform,
                external_file_key=external_key,
                internal_file=global_file
            )
            
            AppFileLink.objects.create(
                app_name=app_name,
                global_file=global_file,
                local_metadata={'copied_from': platform.name}
            )
            
            return Response({'id': global_file.id}, status=201)
            
        except Exception as e:
            logger.error(f"文件复制失败: {str(e)}")
            return Response({'error': '文件复制失败'}, status=500)