import { fetchApi } from '@/lib/server-api-util';
import * as BackgroundFetch from 'expo-background-fetch';
import * as FileSystem from 'expo-file-system';
import * as ImageManipulator from 'expo-image-manipulator';
import * as MediaLibrary from 'expo-media-library';
import * as TaskManager from 'expo-task-manager';
import pLimit from 'p-limit';
import { Alert } from 'react-native';
import { transformData } from '../utils/objectFlat';

type ExtendedAsset = MediaLibrary.Asset & {
    exif?: Record<string, any>;
};

const BACKGROUND_UPLOAD_TASK = 'background-upload-task';
// 设置最大并发数
const CONCURRENCY_LIMIT = 10; // 同时最多上传10个文件
// 在 CONCURRENCY_LIMIT 定义后添加
const limit = pLimit(CONCURRENCY_LIMIT);

// 获取文件扩展名
const getFileExtension = (filename: string) => {
    return filename.split('.').pop()?.toLowerCase() || '';
};

// 获取 MIME 类型
const getMimeType = (filename: string, isVideo: boolean) => {
    if (!isVideo) return 'image/jpeg';

    const ext = getFileExtension(filename);
    switch (ext) {
        case 'mov':
            return 'video/quicktime';
        case 'mp4':
            return 'video/mp4';
        case 'm4v':
            return 'video/x-m4v';
        default:
            return 'video/mp4'; // 默认值
    }
};

// 将 HEIC 图片转化
const convertHeicToJpeg = async (uri: string): Promise<File> => {
    try {
        console.log('Starting HEIC to JPEG conversion for:', uri);

        // 1. 将文件复制到缓存目录
        const cacheDir = FileSystem.cacheDirectory;
        if (!cacheDir) {
            throw new Error('Cache directory not available');
        }

        // 创建唯一的文件名
        const tempUri = `${cacheDir}${Date.now()}.heic`;

        // 复制文件到缓存目录
        await FileSystem.copyAsync({
            from: uri,
            to: tempUri
        });

        // 2. 检查文件是否存在
        const fileInfo = await FileSystem.getInfoAsync(tempUri);
        if (!fileInfo.exists) {
            throw new Error('Temporary file was not created');
        }

        // 3. 读取文件为 base64
        const base64 = await FileSystem.readAsStringAsync(tempUri, {
            encoding: FileSystem.EncodingType.Base64,
        });

        if (!base64) {
            throw new Error('Failed to read file as base64');
        }

        // 4. 创建 Blob
        const response = await fetch(`data:image/jpeg;base64,${base64}`);
        if (!response.ok) {
            throw new Error(`Fetch failed with status ${response.status}`);
        }

        const blob = await response.blob();
        if (!blob || blob.size === 0) {
            throw new Error('Failed to create blob from base64');
        }

        // 5. 创建文件名
        const originalName = uri.split('/').pop() || 'converted';
        const filename = originalName.replace(/\.(heic|heif)$/i, '.jpg');

        console.log('Successfully converted HEIC to JPEG:', filename);

        // 清理临时文件
        try {
            await FileSystem.deleteAsync(tempUri, { idempotent: true });
        } catch (cleanupError) {
            console.warn('Failed to clean up temporary file:', cleanupError);
        }

        return new File([blob], filename, { type: 'image/jpeg' });
    } catch (error: unknown) {
        console.error('Detailed HEIC conversion error:', {
            error: error instanceof Error ? {
                message: error.message,
                name: error.name,
                stack: error.stack
            } : error,
            uri: uri
        });
        throw new Error(`Failed to convert HEIC image: ${error instanceof Error ? error.message : 'An unknown error occurred'}`);
    }
};

// 获取指定时间范围内的媒体文件（包含 EXIF 信息）
export const getMediaByDateRange = async (startDate: Date, endDate: Date) => {
    try {
        const { status } = await MediaLibrary.requestPermissionsAsync();
        if (status !== 'granted') {
            console.warn('Media library permission not granted');
            return [];
        }

        const media = await MediaLibrary.getAssetsAsync({
            mediaType: ['photo', 'video'],
            first: 100,
            sortBy: [MediaLibrary.SortBy.creationTime],
            createdAfter: startDate.getTime(),
            createdBefore: endDate.getTime(),
        });

        // 为每个资源获取完整的 EXIF 信息
        const assetsWithExif = await Promise.all(
            media.assets.map(async (asset) => {
                try {
                    const assetInfo = await MediaLibrary.getAssetInfoAsync(asset.id);
                    return {
                        ...asset,
                        exif: assetInfo.exif || null,
                        location: assetInfo.location || null
                    };
                } catch (error) {
                    console.warn(`Failed to get EXIF for asset ${asset.id}:`, error);
                    return asset;
                }
            })
        );

        return assetsWithExif;
    } catch (error) {
        console.error('Error in getMediaByDateRange:', error);
        return [];
    }
};

// 压缩图片
const compressImage = async (uri: string): Promise<{ uri: string; file: File }> => {
    try {
        const manipResult = await ImageManipulator.manipulateAsync(
            uri,
            [
                {
                    resize: {
                        width: 1200,
                        height: 1200,
                    },
                },
            ],
            {
                compress: 0.7,
                format: ImageManipulator.SaveFormat.JPEG,
                base64: false,
            }
        );

        const response = await fetch(manipResult.uri);
        const blob = await response.blob();
        const filename = uri.split('/').pop() || `image_${Date.now()}.jpg`;
        const file = new File([blob], filename, { type: 'image/jpeg' });

        return { uri: manipResult.uri, file };
    } catch (error) {
        throw error;
    }
};

// 获取上传URL
const getUploadUrl = async (file: File, metadata: Record<string, any> = {}): Promise<{ upload_url: string; file_id: string }> => {

    const body = {
        filename: file.name,
        content_type: file.type,
        file_size: file.size,
        metadata: {
            ...metadata,
            originalName: file.name,
            fileType: file.type.startsWith('video/') ? 'video' : 'image',
            isCompressed: 'true',
        },
    };

    return await fetchApi<{ upload_url: string; file_id: string }>("/file/generate-upload-url", {
        method: 'POST',
        body: JSON.stringify(body)
    });
};

// 确认上传
const confirmUpload = async (file_id: string) => {
    return await fetchApi('/file/confirm-upload', {
        method: 'POST',
        body: JSON.stringify({ file_id })
    });
};

// 新增素材
const addMaterial = async (file: string, compressFile: string) => {
    await fetchApi('/material', {
        method: 'POST',
        body: JSON.stringify([{
            "file_id": file,
            "preview_file_id": compressFile
        }])
    }).catch((error) => {
    })
}

// 上传文件到URL
const uploadFile = async (file: File, uploadUrl: string): Promise<void> => {
    return new Promise((resolve, reject) => {
        const xhr = new XMLHttpRequest();

        xhr.open('PUT', uploadUrl);
        xhr.setRequestHeader('Content-Type', file.type);

        // 进度监听
        xhr.upload.onprogress = (event) => {
            if (event.lengthComputable) {
                const progress = Math.round((event.loaded / event.total) * 100);
            }
        };

        xhr.onload = () => {
            if (xhr.status >= 200 && xhr.status < 300) {
                resolve();
            } else {
                reject(new Error(`Upload failed with status ${xhr.status}`));
            }
        };

        xhr.onerror = () => {
            reject(new Error('Network error during upload'));
        };

        xhr.send(file);
    });
};

// 检查并请求媒体库权限
const checkMediaLibraryPermission = async (): Promise<{ hasPermission: boolean, status?: string }> => {
    try {
        const { status, accessPrivileges } = await MediaLibrary.getPermissionsAsync();

        // 如果已经授权，直接返回
        if (status === 'granted' && accessPrivileges === 'all') {
            return { hasPermission: true, status };
        }

        // 如果没有授权，请求权限
        const { status: newStatus, accessPrivileges: newPrivileges } = await MediaLibrary.requestPermissionsAsync();
        const isGranted = newStatus === 'granted' && newPrivileges === 'all';

        if (!isGranted) {
            console.log('Media library permission not granted or limited access');
        }

        return {
            hasPermission: isGranted,
            status: newStatus
        };
    } catch (error) {
        return { hasPermission: false };
    }
};
// 提取视频的首帧进行压缩并上传
const uploadVideoThumbnail = async (asset: ExtendedAsset) => {
    try {
        const manipResult = await compressImage(asset.uri);
        const response = await fetch(manipResult.uri);
        const blob = await response.blob();
        const filename = asset.filename ?
            `compressed_${asset.filename}` :
            `image_${Date.now()}_compressed.jpg`;
        const compressedFile = new File([blob], filename, { type: 'image/jpeg' });

        const { upload_url, file_id } = await getUploadUrl(compressedFile, {
            originalUri: asset.uri,
            creationTime: asset.creationTime,
            mediaType: 'image',
            isCompressed: true
        });

        await uploadFile(compressedFile, upload_url);
        await confirmUpload(file_id);

        console.log('视频首帧文件上传成功:', {
            fileId: file_id,
            filename: compressedFile.name,
            type: compressedFile.type
        });
        return { success: true, file_id };
    } catch (error) {
        return { success: false, error };
    }
};
// 处理单个媒体文件上传
const processMediaUpload = async (asset: ExtendedAsset) => {
    try {
        // 检查权限
        const { hasPermission } = await checkMediaLibraryPermission();
        if (!hasPermission) {
            throw new Error('No media library permission');
        }

        const isVideo = asset.mediaType === 'video';

        // 上传原始文件
        const uploadOriginalFile = async () => {
            try {
                let fileToUpload: File;
                const isVideo = asset.mediaType === 'video';
                const mimeType = getMimeType(asset.filename || '', isVideo);

                // 生成文件名，保留原始扩展名
                let filename = asset.filename ||
                    `${isVideo ? 'video' : 'image'}_${Date.now()}_original.${isVideo ? (getFileExtension(asset.filename || 'mp4') || 'mp4') : 'jpg'}`;

                // 处理 HEIC 格式
                if (filename.toLowerCase().endsWith('.heic') || filename.toLowerCase().endsWith('.heif')) {
                    fileToUpload = await convertHeicToJpeg(asset.uri);
                    filename = filename.replace(/\.(heic|heif)$/i, '.jpg');
                } else {
                    // 获取资源信息
                    const assetInfo = await MediaLibrary.getAssetInfoAsync(asset.id, {
                        shouldDownloadFromNetwork: true
                    });

                    if (!assetInfo.localUri) {
                        throw new Error('无法获取资源的本地路径');
                    }

                    // 获取文件扩展名
                    const fileExtension = getFileExtension(assetInfo.filename || '') ||
                        (isVideo ? 'mp4' : 'jpg');

                    // 确保文件名有正确的扩展名
                    if (!filename.toLowerCase().endsWith(`.${fileExtension}`)) {
                        const baseName = filename.split('.')[0];
                        filename = `${baseName}.${fileExtension}`;
                    }

                    // 获取文件内容
                    const response = await fetch(assetInfo.localUri);
                    const blob = await response.blob();

                    // 创建文件对象
                    fileToUpload = new File([blob], filename, { type: mimeType });
                    console.log('文件准备上传:', {
                        name: fileToUpload.name,
                        type: fileToUpload.type,
                        size: fileToUpload.size
                    });
                }

                // 准备元数据
                let exifData = {};
                if (asset.exif) {
                    try {
                        exifData = transformData({
                            ...asset,
                            exif: {
                                ...asset.exif,
                                '{MakerApple}': undefined
                            }
                        });
                    } catch (exifError) {
                        console.warn('处理 EXIF 数据时出错:', exifError);
                    }
                }

                // 获取上传 URL
                const { upload_url, file_id } = await getUploadUrl(fileToUpload, {
                    originalUri: asset.uri,
                    creationTime: asset.creationTime,
                    mediaType: isVideo ? 'video' : 'image',
                    isCompressed: false,
                    ...exifData,
                    GPSVersionID: undefined
                });

                // 上传文件
                await uploadFile(fileToUpload, upload_url);
                await confirmUpload(file_id);

                console.log('文件上传成功:', {
                    fileId: file_id,
                    filename: fileToUpload.name,
                    type: fileToUpload.type
                });

                return {
                    success: true,
                    file_id,
                    filename: fileToUpload.name
                };

            } catch (error: any) {
                const errorMessage = error instanceof Error ? error.message : '未知错误';
                console.error('上传原始文件时出错:', {
                    error: errorMessage,
                    assetId: asset.id,
                    filename: asset.filename,
                    uri: asset.uri
                });
                throw new Error(`上传失败: ${errorMessage}`);
            }
        };

        // 上传压缩文件（仅图片）
        const uploadCompressedFile = async () => {
            if (isVideo) return { success: true, file_id: null }; // 视频不压缩

            try {
                const manipResult = await compressImage(asset.uri);
                const response = await fetch(manipResult.uri);
                const blob = await response.blob();
                const filename = asset.filename ?
                    `compressed_${asset.filename}` :
                    `image_${Date.now()}_compressed.jpg`;
                const compressedFile = new File([blob], filename, { type: 'image/jpeg' });

                const { upload_url, file_id } = await getUploadUrl(compressedFile, {
                    originalUri: asset.uri,
                    creationTime: asset.creationTime,
                    mediaType: 'image',
                    isCompressed: true
                });

                await uploadFile(compressedFile, upload_url);
                await confirmUpload(file_id);
                return { success: true, file_id };
            } catch (error) {
                return { success: false, error };
            }
        };

        // 先上传原始文件
        const originalResult = await uploadOriginalFile();

        // 如果是图片，再上传压缩文件
        let compressedResult = { success: true, file_id: null };
        if (!isVideo) {
            compressedResult = await uploadCompressedFile();
            // 添加素材
            addMaterial(originalResult.file_id, compressedResult?.file_id || '');
        } else {
            // 上传压缩首帧
            uploadVideoThumbnail(asset)
        }

        return {
            originalSuccess: originalResult.success,
            compressedSuccess: compressedResult.success,
            fileIds: {
                original: originalResult.file_id,
                compressed: compressedResult.file_id
            }
        };
    } catch (error: any) {
        if (error.message === 'No media library permission') {
            throw error;
        }
        return {
            originalSuccess: false,
            compressedSuccess: false,
            error: error.message
        };
    }
};

// 注册后台任务
export const registerBackgroundUploadTask = async () => {
    try {
        // 检查是否已经注册了任务
        const isRegistered = await TaskManager.isTaskRegisteredAsync(BACKGROUND_UPLOAD_TASK);
        if (isRegistered) {
            await BackgroundFetch.unregisterTaskAsync(BACKGROUND_UPLOAD_TASK);
        }

        // 注册后台任务
        await BackgroundFetch.registerTaskAsync(BACKGROUND_UPLOAD_TASK, {
            minimumInterval: 15 * 60, // 15 分钟
            stopOnTerminate: false,   // 应用退出后继续运行
            startOnBoot: true,        // 设备启动后自动启动
        });

        console.log('Background task registered');
        return true;
    } catch (error) {
        console.error('Error registering background task:', error);
        return false;
    }
};

// 定义后台任务
TaskManager.defineTask(BACKGROUND_UPLOAD_TASK, async () => {
    try {
        const now = new Date();
        const oneDayAgo = new Date(now.getTime() - 24 * 60 * 60 * 1000);

        // 获取最近24小时的媒体文件
        const media = await getMediaByDateRange(oneDayAgo, now);

        if (media.length === 0) {
            console.log('No media files to upload');
            return BackgroundFetch.BackgroundFetchResult.NoData;
        }

        // 处理媒体文件上传
        const results = await triggerManualUpload(oneDayAgo, now);
        const successCount = results.filter(r => r.originalSuccess).length;

        console.log(`Background upload completed. Success: ${successCount}/${results.length}`);

        return successCount > 0
            ? BackgroundFetch.BackgroundFetchResult.NewData
            : BackgroundFetch.BackgroundFetchResult.NoData;
    } catch (error) {
        console.error('Background task error:', error);
        return BackgroundFetch.BackgroundFetchResult.Failed;
    }
});

// 手动触发上传
export const triggerManualUpload = async (startDate: Date, endDate: Date) => {
    try {
        const media = await getMediaByDateRange(startDate, endDate);
        if (media.length === 0) {
            Alert.alert('提示', '在指定时间范围内未找到媒体文件');
            return [];
        }

        // 分离图片和视频
        const photos = media.filter(item => item.mediaType === 'photo');
        const videos = media.filter(item => item.mediaType === 'video');
        console.log('videos11111111', videos);

        const results: any[] = [];

        // 处理所有图片（带并发控制）
        const processPhoto = async (item: any) => {
            try {
                const result = await processMediaUpload(item);
                results.push({
                    id: item.id,
                    ...result
                });
            } catch (error: any) {
                results.push({
                    id: item.id,
                    originalSuccess: false,
                    compressedSuccess: false,
                    error: error.message
                });
            }
        };

        // 处理所有视频（带并发控制）
        const processVideo = async (item: any) => {
            try {
                const result = await processMediaUpload(item);
                results.push({
                    id: item.id,
                    ...result
                });
            } catch (error: any) {
                results.push({
                    id: item.id,
                    originalSuccess: false,
                    compressedSuccess: false,
                    error: error.message
                });
            }
        };

        // 并发处理图片和视频
        await Promise.all([
            ...photos.map(photo => limit(() => processPhoto(photo))),
            ...videos.map(video => limit(() => processVideo(video)))
        ]);

        return results;
    } catch (error) {
        Alert.alert('错误', '上传过程中出现错误');
        throw error;
    }
};