package com.offline.music.player.service;

import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.content.res.AssetFileDescriptor;
import android.media.MediaPlayer;
import android.net.Uri;
import android.os.Binder;
import android.os.Build;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.os.PowerManager;
import android.util.Log;
import android.widget.Toast;

import androidx.annotation.Nullable;
import androidx.core.app.NotificationCompat;
import androidx.lifecycle.LiveData;
import androidx.lifecycle.MutableLiveData;

import com.offline.music.player.R;
import com.offline.music.player.javabean.A_data.AudioItem;
import com.offline.music.player.ui.activity.A_PlayActivity;

import java.io.File;
import java.io.IOException;

public class MusicPlayerForegroundService extends Service {

    // 通知渠道ID
    public static final String CHANNEL_ID = "MusicPlayerChannel";
    private MediaPlayer mediaPlayer; // 播放音频的MediaPlayer实例
    private final IBinder binder = new MusicBinder(); // 用于绑定服务的Binder
    private final MutableLiveData<Boolean> isPlaying = new MutableLiveData<>(false); // 播放状态
    private final MutableLiveData<String> fileName = new MutableLiveData<>(); // 当前播放的文件名
    private MutableLiveData<Integer> remainingTimeLiveData = new MutableLiveData<>(); // 创建LiveData
    private AudioItem audioItem; // 当前播放的音频项
    private String currentAudioPath = null; // 当前播放的音频路径
    private PowerManager.WakeLock wakeLock; // 用于防止设备休眠
    private boolean isLooping = true; // 循环播放标志
    private Handler timerHandler; // 用于管理倒计时
    private Runnable timerRunnable; // 倒计时Runnable
    private int remainingTime; // 剩余时间（毫秒）
    private boolean isTimerRunning = false; // 计时器状态
    private boolean isTimerPaused = false; // 计时器是否暂停
    private MutableLiveData<Integer> currentPosition = new MutableLiveData<>();
    private MutableLiveData<Integer> duration = new MutableLiveData<>();


    // 自定义Binder类
    public class MusicBinder extends Binder {
        public MusicPlayerForegroundService getService() {
            return MusicPlayerForegroundService.this; // 返回当前服务实例
        }
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return binder; // 返回Binder
    }

    // 服务启动时调用
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d("MusicPlayerService", "Service started");
        audioItem = (AudioItem) intent.getSerializableExtra("Path"); // 获取音频路径

        if (audioItem != null) {
            String newAudioPath = audioItem.getFile();
            // 如果新音频路径不同于当前路径，则重新初始化播放器
            if (newAudioPath != null && !newAudioPath.equals(currentAudioPath)) {
                Log.d("MusicPlayerService", "检测到新的音频路径，初始化播放器");
                currentAudioPath = newAudioPath; // 更新路径
                stopAndResetMediaPlayer(); // 停止并重置播放器
                initializePlayer(newAudioPath); // 初始化播放器
            } else {
                Log.d("MusicPlayerService", "音频路径相同，无需重新初始化播放器");
            }
        } else {
            stopSelf(); // 路径为空，停止服务
        }

        startForeground(1, createNotification()); // 启动前台服务并显示通知
        acquireWakeLock(); // 获取WakeLock

        return START_NOT_STICKY; // 服务不会在被杀死后自动重启
    }

    // 创建通知
    private Notification createNotification() {
        createNotificationChannel(); // 创建通知渠道
        Intent notificationIntent = new Intent(this, A_PlayActivity.class);
        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent,
                Build.VERSION.SDK_INT >= Build.VERSION_CODES.S ? PendingIntent.FLAG_IMMUTABLE : 0); // 适配Android 12

        return new NotificationCompat.Builder(this, CHANNEL_ID)
                .setContentTitle("正在播放音频") // 通知标题
                .setContentText("您的音频正在播放") // 通知内容
                .setSmallIcon(R.drawable.home_select) // 小图标
                .setContentIntent(pendingIntent) // 点击通知的Intent
                .setPriority(NotificationCompat.PRIORITY_LOW) // 低优先级
                .build();
    }

    // 创建通知渠道
    private void createNotificationChannel() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            NotificationChannel serviceChannel = new NotificationChannel(
                    CHANNEL_ID, "音乐播放器频道", NotificationManager.IMPORTANCE_LOW);
            NotificationManager manager = getSystemService(NotificationManager.class);
            if (manager != null) {
                manager.createNotificationChannel(serviceChannel); // 创建渠道
            }
        }
    }

    // 停止并重置播放器
    public void stopAndResetMediaPlayer() {
        if (mediaPlayer != null) {
            if (mediaPlayer.isPlaying()) {
                mediaPlayer.stop(); // 停止播放
            }
            mediaPlayer.reset(); // 重置播放器
        }
    }

    // 初始化播放器
    private void initializePlayer(String path) {
        try {
            Log.d("MusicPlayerService", "正在初始化播放器，音频路径: " + path);
            if (mediaPlayer == null) {
                mediaPlayer = new MediaPlayer(); // 创建新的MediaPlayer实例
            }

            fileName.setValue(audioItem.getName()); // 设置当前文件名
            setDataSource(path); // 设置数据源

            mediaPlayer.prepareAsync(); // 异步准备
            mediaPlayer.setOnPreparedListener(mp -> {
                mediaPlayer.start(); // 播放器准备好后开始播放
                isPlaying.postValue(true); // 更新播放状态
            });

            // 播放完成监听
            mediaPlayer.setOnCompletionListener(mp -> {
                if (isLooping) {
                    mediaPlayer.seekTo(0); // 循环播放
                    mediaPlayer.start();
                } else {
                    isPlaying.postValue(false); // 更新播放状态
                    stopSelf(); // 播放完成后停止服务
                }
            });

            // 播放错误监听
            mediaPlayer.setOnErrorListener((mp, what, extra) -> {
                Log.e("MusicPlayerService", "播放时发生错误: " + what + ", 额外信息: " + extra);
                isPlaying.postValue(false); // 更新状态
                stopSelf(); // 播放出错后停止服务
                return true; // 表示错误已处理
            });

        } catch (IOException | IllegalArgumentException | IllegalStateException e) {
            Log.e("MusicPlayerService", "初始化播放器失败，路径: " + path, e);
            isPlaying.postValue(false); // 更新状态
            stopSelf(); // 停止服务
        }
    }

    // 设置数据源
    private void setDataSource(String path) throws IOException {
        if (path.startsWith("content://")) {
            setDataSourceFromContentUri(path); // 使用内容URI加载
        } else {
            setDataSourceFromFileOrAsset(path); // 从文件或资产加载
        }
    }

    // 使用内容URI加载音频
    private void setDataSourceFromContentUri(String path) throws IOException {
        Uri contentUri = Uri.parse(path); // 解析URI
        try (AssetFileDescriptor afd = getContentResolver().openAssetFileDescriptor(contentUri, "r")) {
            if (afd != null) {
                mediaPlayer.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength()); // 设置数据源
            } else {
                throw new IOException("无法打开内容URI: " + path);
            }
        } catch (SecurityException e) {
            Log.e("MusicPlayerService", "权限被拒绝，无法访问内容URI: " + path, e);
            throw new IOException("权限被拒绝", e); // 处理权限异常
        }
    }

    // 从文件或assets加载音频
    private void setDataSourceFromFileOrAsset(String path) throws IOException {
        try {
            AssetFileDescriptor afd = getAssets().openFd(path); // 从assets加载
            mediaPlayer.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength());
        } catch (IOException e) {
            File file = new File(path);
            if (file.exists()) {
                mediaPlayer.setDataSource(file.getAbsolutePath()); // 从文件加载
            } else {
                throw new IOException("文件未找到: " + path);
            }
        }
    }

    // 获取文件名
    // 获取文件名（不带扩展名）
    private String getFileNameFromPath(String path) {
        try {
            // 创建File对象并获取文件名
            String fileName = new File(path).getName();
            // 找到最后一个点的位置
            int dotIndex = fileName.lastIndexOf('.');
            // 如果找到了点，返回不带扩展名的文件名
            return (dotIndex > 0) ? fileName.substring(0, dotIndex) : fileName;
        } catch (Exception e) {
            Log.e("MusicPlayerService", "获取文件名失败", e);
            return "未知文件"; // 默认文件名
        }
    }

    // 开始或重新开始计时器
    public void startTimer(int duration) {
        if (isTimerRunning && !isTimerPaused) {
            stopTimer(); // 如果计时器已经运行并且没有暂停，则重新开始计时器前先停止
        }
        remainingTime = duration; // 重置计时器时间
        isTimerPaused = false; // 清除暂停状态
        isTimerRunning = true; // 标记计时器正在运行
        timerHandler = new Handler(Looper.getMainLooper());

        timerRunnable = new Runnable() {
            @Override
            public void run() {
                if (remainingTime > 0) {
                    remainingTime -= 1000; // 每秒减少1秒
                    remainingTimeLiveData.postValue(remainingTime); // 更新LiveData，通知UI
                    timerHandler.postDelayed(this, 1000); // 每秒更新一次
                } else {
                    pauseAudio(); // 时间到，暂停音乐
                    isPlaying.postValue(false); // 更新播放状态
                    Toast.makeText(getApplicationContext(), "定时器结束", Toast.LENGTH_SHORT).show();
                    stopTimer(); // 时间到，结束计时器
                }
            }
        };
        timerHandler.postDelayed(timerRunnable, 1000); // 启动计时器
    }

    // 暂停计时器
    public void pauseTimer() {
        if (isTimerRunning && !isTimerPaused) {
            isTimerPaused = true; // 标记为暂停状态
            timerHandler.removeCallbacks(timerRunnable); // 暂停计时器
        }
    }

    // 恢复计时器
    public void resumeTimer() {
        if (isTimerRunning && isTimerPaused) {
            isTimerPaused = false; // 清除暂停状态
            timerHandler.postDelayed(timerRunnable, 1000); // 恢复计时器
        }
    }

    // 结束计时器
    public void stopTimer() {
        isTimerRunning = false; // 更新状态
        isTimerPaused = false; // 清除暂停状态
        if (timerHandler != null && timerRunnable != null) {
            timerHandler.removeCallbacks(timerRunnable); // 移除所有回调，停止计时器
        }
    }

    // 暂停播放
    public void pauseAudio() {
        if (mediaPlayer != null && mediaPlayer.isPlaying()) {
            mediaPlayer.pause(); // 暂停
            isPlaying.postValue(false); // 更新状态
        }
    }

    // 恢复播放
    public void resumeAudio() {
        if (mediaPlayer != null && !mediaPlayer.isPlaying()) {
            mediaPlayer.start(); // 恢复播放
            isPlaying.postValue(true); // 更新状态
        }
    }

    // 获取播放状态
    public MutableLiveData<Boolean> getIsPlaying() {
        return isPlaying;
    }

    // 获取当前文件名
    public MutableLiveData<String> getFileName() {
        return fileName;
    }


    //获取audioItem
    public AudioItem getAudioItem() {
        return audioItem;
    }

    //获取计时器时间
    public LiveData<Integer> getRemainingTimeLiveData() {
        return remainingTimeLiveData; // 提供LiveData访问
    }

    // 获取当前播放位置的 LiveData
    public LiveData<Integer> getCurrentPositionLiveData() {
        return currentPosition;
    }

    // 获取音频总时长的 LiveData
    public LiveData<Integer> getDurationLiveData() {
        return duration;
    }

    // 获取音频总时长（毫秒）
    public int getDuration() {
        return mediaPlayer != null ? mediaPlayer.getDuration() : 0;
    }

    // 播放音频时更新进度
    public void startUpdatingProgress() {
        // 获取音频总时长
        if (mediaPlayer != null) {
            duration.postValue(mediaPlayer.getDuration());
        }

        // 使用 Handler 定时更新 currentPosition
        Handler handler = new Handler(Looper.getMainLooper());
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                if (mediaPlayer != null && mediaPlayer.isPlaying()) {
                    currentPosition.postValue(mediaPlayer.getCurrentPosition());
                    handler.postDelayed(this, 1000);  // 每隔1秒更新一次
                }
            }
        };
        handler.post(runnable);  // 启动更新
    }

    // 跳转到指定播放位置
    public void seekTo(int position) {
        if (mediaPlayer != null) {
            mediaPlayer.seekTo(position); // 跳转到指定位置
        }
    }

    // 获取WakeLock
    private void acquireWakeLock() {
        PowerManager powerManager = (PowerManager) getSystemService(Context.POWER_SERVICE);
        if (powerManager != null) {
            wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
                    "MusicPlayer::WakeLock");
            wakeLock.acquire(10 * 60 * 1000L); // 获取WakeLock，防止设备休眠
        }
    }

    // 销毁服务时释放资源
    @Override
    public void onDestroy() {
        super.onDestroy();
        // 释放WakeLock
        if (wakeLock != null && wakeLock.isHeld()) {
            wakeLock.release();
            wakeLock = null; // 释放后设置为null
        }
        if (mediaPlayer != null) {
            mediaPlayer.release(); // 释放MediaPlayer资源
            mediaPlayer = null; // 设置为null
        }
        stopTimer();
    }
}
