import SwiftUI
import AVFoundation
import MediaPlayer
import UIKit

struct ContentView: View {
    @State var audioPlayer: AVAudioPlayer?
    @State var songTitle = "Выберите трек из iCloud"
    @State var isPlaying = false
    @State var showingDocumentPicker = false
    @State var currentTime: TimeInterval = 0
    @State var duration: TimeInterval = 0
    @State var timer: Timer?
    @State var currentRoute = "iPhone"
    @State var tracks: [Track] = []
    @State var currentTrackIndex = 0
    @State var showingPlaylist = true
    @State private var currentArtworkImage: UIImage? = nil
    /// Должен жить, пока играет `AVAudioPlayer`: у делегата слабая ссылка, иначе `audioPlayerDidFinishPlaying` не вызывается.
    @State private var audioPlayerCoordinator: AudioPlayerCoordinator?
    
    var body: some View {
        ZStack {
            Color.clear
                .background(
                    VisualEffectView(effect: UIBlurEffect(style: .systemUltraThinMaterial))
                        .ignoresSafeArea()
                )
            
            VStack(spacing: 20) {
                Text("CloudPlayer")
                    .font(.largeTitle)
                    .fontWeight(.bold)
                    .foregroundStyle(.primary)
                    .padding(.top, 20)
                
                GlassView(cornerRadius: 20) {
                    VStack(spacing: 15) {
                        Group {
                            if let currentArtworkImage {
                                Image(uiImage: currentArtworkImage)
                                    .resizable()
                                    .scaledToFill()
                                    .frame(width: 140, height: 140)
                                    .clipShape(RoundedRectangle(cornerRadius: 18, style: .continuous))
                                    .overlay(
                                        RoundedRectangle(cornerRadius: 18, style: .continuous)
                                            .stroke(.white.opacity(0.2), lineWidth: 1)
                                    )
                            } else {
                                Image(systemName: "music.note")
                                    .font(.system(size: 60))
                                    .foregroundStyle(.secondary)
                                    .frame(width: 140, height: 140)
                                    .background(
                                        RoundedRectangle(cornerRadius: 18, style: .continuous)
                                            .fill(.thinMaterial)
                                            .opacity(0.35)
                                    )
                                    .clipShape(RoundedRectangle(cornerRadius: 18, style: .continuous))
                            }
                        }
                        
                        Text(songTitle)
                            .font(.title2)
                            .foregroundStyle(.primary)
                            .lineLimit(2)
                            .multilineTextAlignment(.center)
                            .padding(.horizontal)
                        
                        HStack {
                            Image(systemName: audioRouteIcon)
                                .foregroundStyle(.secondary)
                            Text(currentRoute)
                                .font(.caption)
                                .foregroundStyle(.secondary)
                        }
                        
                        // Индикатор длительного трека
                        if duration > 3600 {
                            HStack {
                                Image(systemName: "clock")
                                    .font(.caption2)
                                Text("Длительный трек (\(formatTime(duration)))")
                                    .font(.caption2)
                                    .foregroundStyle(.secondary)
                            }
                        }
                        
                        if duration > 0 {
                            VStack {
                                Slider(value: $currentTime, in: 0...duration, onEditingChanged: { editing in
                                    if editing {
                                        self.timer?.invalidate()
                                        self.timer = nil
                                    } else {
                                        self.audioPlayer?.currentTime = currentTime
                                        self.updateNowPlaying()
                                        
                                        if self.isPlaying {
                                            self.startTimer()
                                        }
                                    }
                                })
                                .disabled(audioPlayer == nil)
                                .tint(.blue)
                                
                                HStack {
                                    Text(formatTime(currentTime))
                                        .font(.caption)
                                        .foregroundStyle(.secondary)
                                    Spacer()
                                    Text(formatTime(duration))
                                        .font(.caption)
                                        .foregroundStyle(.secondary)
                                }
                            }
                        }
                        
                        HStack(spacing: 50) {
                            Button(action: playPreviousTrack) {
                                Image(systemName: "backward.fill")
                                    .font(.title)
                                    .foregroundStyle(tracks.isEmpty ? .gray : .blue)
                            }
                            .disabled(tracks.isEmpty)
                            
                            Button(action: togglePlayPause) {
                                Image(systemName: isPlaying ? "pause.circle.fill" : "play.circle.fill")
                                    .font(.system(size: 50))
                                    .foregroundStyle(isPlaying ? .orange : .green)
                            }
                            .disabled(audioPlayer == nil && tracks.isEmpty)
                            
                            Button(action: playNextTrack) {
                                Image(systemName: "forward.fill")
                                    .font(.title)
                                    .foregroundStyle(tracks.isEmpty ? .gray : .blue)
                            }
                            .disabled(tracks.isEmpty)
                        }
                    }
                    .padding()
                }
                .padding(.horizontal)
                
                Button(action: {
                    showingDocumentPicker = true
                }) {
                    Label("Добавить в плейлист", systemImage: "plus.circle")
                        .frame(maxWidth: .infinity)
                        .padding()
                        .background(
                            GlassView(cornerRadius: 10) {
                                Color.clear
                            }
                        )
                        .foregroundColor(.blue)
                }
                .padding(.horizontal)
                
                if showingPlaylist {
                    GlassView(cornerRadius: 20) {
                        VStack(alignment: .leading, spacing: 10) {
                            HStack {
                                Text("Плейлист")
                                    .font(.headline)
                                    .foregroundStyle(.primary)
                                Spacer()
                                Text("\(tracks.count) треков")
                                    .font(.caption)
                                    .foregroundStyle(.secondary)
                                
                                Button(action: {
                                    withAnimation(.spring()) {
                                        showingPlaylist.toggle()
                                    }
                                }) {
                                    Image(systemName: "chevron.down")
                                        .foregroundStyle(.secondary)
                                }
                            }
                            .padding(.horizontal)
                            .padding(.top, 10)
                            
                            if tracks.isEmpty {
                                Text("Нет треков. Нажмите + чтобы добавить")
                                    .font(.caption)
                                    .foregroundStyle(.secondary)
                                    .frame(maxWidth: .infinity, alignment: .center)
                                    .padding()
                            } else {
                                ScrollView {
                                    LazyVStack(spacing: 5) {
                                        ForEach(Array(tracks.enumerated()), id: \.element.id) { index, track in
                                            PlaylistRow(
                                                track: track,
                                                index: index,
                                                isCurrentTrack: index == currentTrackIndex,
                                                isPlaying: isPlaying && index == currentTrackIndex,
                                                onSelect: { idx in
                                                    playTrack(at: idx)
                                                },
                                                onDelete: { idx in
                                                    deleteTrack(at: idx)
                                                }
                                            )
                                        }
                                    }
                                    .padding(.horizontal, 5)
                                }
                                .frame(maxHeight: 250)
                            }
                        }
                        .padding(.bottom, 10)
                    }
                    .padding(.horizontal)
                    .transition(.move(edge: .bottom).combined(with: .opacity))
                } else {
                    Button(action: {
                        withAnimation(.spring()) {
                            showingPlaylist = true
                        }
                    }) {
                        HStack {
                            Image(systemName: "music.note.list")
                            Text("Показать плейлист (\(tracks.count))")
                        }
                        .padding()
                        .background(
                            GlassView(cornerRadius: 10) {
                                Color.clear
                            }
                        )
                    }
                    .padding(.horizontal)
                }
                
                Spacer()
            }
        }
        .sheet(isPresented: $showingDocumentPicker) {
            DocumentPicker { url in
                addTrackToPlaylist(url)
            }
        }
        .onAppear {
            setupRemoteTransportControls()
            checkAudioRoute()
            loadPlaylist()
        }
        .onReceive(NotificationCenter.default.publisher(for: UIApplication.willTerminateNotification)) { _ in
            timer?.invalidate()
            timer = nil
            savePlaylist()
        }
    }
    
    // MARK: - AirPods и аудиомаршруты
    
    var audioRouteIcon: String {
        if currentRoute.contains("AirPods") {
            return "airpodspro"
        } else if currentRoute.contains("Bluetooth") || currentRoute.contains("наушники") {
            return "headphones"
        } else {
            return "speaker.wave.2"
        }
    }
    
    func checkAudioRoute() {
        let audioSession = AVAudioSession.sharedInstance()
        let currentRoute = audioSession.currentRoute
        
        if let output = currentRoute.outputs.first {
            DispatchQueue.main.async {
                self.currentRoute = output.portName
            }
            print("Аудиовыход: \(output.portName) (\(output.portType.rawValue))")
        }
    }
    
    // MARK: - Настройка аудиосессии - ОПТИМИЗИРОВАННАЯ ДЛЯ BLUETOOTH

    func setupAudioSession() {
        let audioSession = AVAudioSession.sharedInstance()
        
        // Сначала пробуем полную настройку с Bluetooth опциями
        do {
            try audioSession.setCategory(
                .playback,
                mode: .default,
                options: [.allowAirPlay, .allowBluetoothA2DP, .allowBluetoothHFP]
            )
            try audioSession.setActive(true)
            print("✅ Аудиосессия: полная настройка с Bluetooth")
            checkAudioRoute()
            return
        } catch {
            print("⚠️ Полная настройка не удалась: \(error.localizedDescription)")
        }
        
        // Пробуем с A2DP без HFP
        do {
            try audioSession.setCategory(
                .playback,
                mode: .default,
                options: [.allowAirPlay, .allowBluetoothA2DP]
            )
            try audioSession.setActive(true)
            print("✅ Аудиосессия: настройка с A2DP")
            checkAudioRoute()
            return
        } catch {
            print("⚠️ Настройка с A2DP не удалась: \(error.localizedDescription)")
        }
        
        // Пробуем без Bluetooth опций
        do {
            try audioSession.setCategory(.playback, mode: .default)
            try audioSession.setActive(true)
            print("✅ Аудиосессия: стандартная настройка")
            checkAudioRoute()
            return
        } catch {
            print("⚠️ Стандартная настройка не удалась: \(error.localizedDescription)")
        }
        
        // Минимальная настройка
        do {
            try audioSession.setCategory(.playback)
            try audioSession.setActive(true)
            print("✅ Аудиосессия: минимальная настройка")
        } catch {
            print("❌ Не удалось настроить аудиосессию: \(error.localizedDescription)")
        }
        
        checkAudioRoute()
    }
    
    // MARK: - Управление плейлистом
    
    func addTrackToPlaylist(_ url: URL) {
        print("Добавление трека: \(url.lastPathComponent)")
        
        guard FileManager.default.fileExists(atPath: url.path) else {
            songTitle = "Файл не существует"
            return
        }
        
        let didStartAccessing = url.startAccessingSecurityScopedResource()
        
        defer {
            if didStartAccessing {
                url.stopAccessingSecurityScopedResource()
            }
        }
        
        let documentsURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
        let destinationURL = documentsURL.appendingPathComponent(UUID().uuidString).appendingPathExtension(url.pathExtension)
        
        do {
            try FileManager.default.copyItem(at: url, to: destinationURL)
            copySidecarArtworkIfExists(from: url, toAudioURL: destinationURL)
            
            Task {
                do {
                    let asset = AVURLAsset(url: destinationURL)
                    let duration = try await asset.load(.duration).seconds
                    
                    await MainActor.run {
                        let track = Track(name: url.lastPathComponent, url: destinationURL, duration: duration)
                        self.tracks.append(track)
                        self.savePlaylist()
                        
                        if self.tracks.count == 1 {
                            self.playTrack(at: 0)
                        }
                        
                        print("✅ Трек добавлен в плейлист")
                    }
                } catch {
                    await MainActor.run {
                        let track = Track(name: url.lastPathComponent, url: destinationURL, duration: 0)
                        self.tracks.append(track)
                        self.savePlaylist()
                        
                        print("⚠️ Трек добавлен с длительностью 0: \(error.localizedDescription)")
                    }
                }
            }
            
        } catch {
            print("❌ Ошибка копирования трека: \(error.localizedDescription)")
            songTitle = "Ошибка копирования файла"
        }
    }
    
    func playTrack(at index: Int) {
        print("▶️ playTrack at index: \(index)")
        guard index >= 0 && index < tracks.count else {
            print("⚠️ Индекс вне диапазона")
            return
        }
        
        if isPlaying {
            audioPlayer?.stop()
            isPlaying = false
        }
        
        timer?.invalidate()
        timer = nil
        audioPlayer = nil
        
        let track = tracks[index]
        currentTrackIndex = index
        songTitle = track.name
        duration = track.duration
        updateCurrentArtwork(for: track)
        
        print("🎵 Загружаем трек: \(track.name)")
        
        // Настраиваем аудиосессию
        setupAudioSession()
        
        if audioPlayerCoordinator == nil {
            audioPlayerCoordinator = AudioPlayerCoordinator(self)
        }
        
        do {
            // Создаем плеер
            audioPlayer = try AVAudioPlayer(contentsOf: track.url)
            audioPlayer?.prepareToPlay()
            audioPlayer?.delegate = audioPlayerCoordinator
            audioPlayer?.currentTime = 0
            audioPlayer?.volume = 1.0
            
            currentTime = 0
            
            // Пробуем воспроизвести
            let played = audioPlayer?.play() ?? false
            isPlaying = played
            
            if played {
                print("✅ Воспроизведение началось")
                startTimer()
                updateNowPlaying()
            } else {
                print("❌ Не удалось начать воспроизведение")
                songTitle = "Ошибка воспроизведения"
            }
            
            print("▶️ Воспроизведение трека \(index + 1): \(track.name)")
            
        } catch {
            songTitle = "Ошибка: \(error.localizedDescription)"
            print("❌ Ошибка создания плеера: \(error.localizedDescription)")
        }
    }
    
    func playNextTrack() {
        print("🎵 ==================================")
        print("🎵 Вызван playNextTrack")
        print("🎵 Текущий индекс: \(currentTrackIndex)")
        print("🎵 Всего треков: \(tracks.count)")
        print("🎵 ==================================")
        
        guard !tracks.isEmpty else {
            print("🎵 Плейлист пуст")
            return
        }
        
        if isPlaying {
            audioPlayer?.stop()
            isPlaying = false
        }
        
        timer?.invalidate()
        timer = nil
        audioPlayer = nil
        
        let nextIndex = (currentTrackIndex + 1) % tracks.count
        print("🎵 Переключаем с индекса \(currentTrackIndex) на \(nextIndex)")
        
        playTrack(at: nextIndex)
    }
    
    func playPreviousTrack() {
        print("▶️ Вызван playPreviousTrack")
        guard !tracks.isEmpty else { return }
        
        if isPlaying {
            audioPlayer?.stop()
            isPlaying = false
        }
        
        timer?.invalidate()
        timer = nil
        audioPlayer = nil
        
        let previousIndex = (currentTrackIndex - 1 + tracks.count) % tracks.count
        print("🔄 Переключаем с индекса \(currentTrackIndex) на \(previousIndex)")
        
        playTrack(at: previousIndex)
    }
    
    func deleteTrack(at index: Int) {
        guard index >= 0 && index < tracks.count else { return }
        
        let track = tracks[index]
        try? FileManager.default.removeItem(at: track.url)
        tracks.remove(at: index)
        
        if index == currentTrackIndex {
            if tracks.isEmpty {
                audioPlayer?.stop()
                audioPlayer = nil
                isPlaying = false
                songTitle = "Выберите трек из iCloud"
                duration = 0
                currentTime = 0
                currentArtworkImage = nil
                timer?.invalidate()
                timer = nil
                currentTrackIndex = 0
            } else if currentTrackIndex >= tracks.count {
                currentTrackIndex = tracks.count - 1
                playTrack(at: currentTrackIndex)
            } else {
                playTrack(at: currentTrackIndex)
            }
        } else if index < currentTrackIndex {
            currentTrackIndex -= 1
        }
        
        savePlaylist()
    }
    
    func togglePlayPause() {
        if isPlaying {
            pause()
        } else {
            if audioPlayer != nil {
                play()
            } else if !tracks.isEmpty {
                playTrack(at: currentTrackIndex)
            }
        }
    }
    
    // MARK: - Таймер
    
    func startTimer() {
        timer?.invalidate()
        
        // Для длинных треков можно увеличить интервал обновления
        let timeInterval: TimeInterval = duration > 3600 ? 1.0 : 0.1
        
        timer = Timer.scheduledTimer(withTimeInterval: timeInterval, repeats: true) { _ in
            DispatchQueue.main.async {
                self.currentTime = self.audioPlayer?.currentTime ?? 0
                self.updateNowPlaying()
                
                // Проверка окончания трека
                if let player = self.audioPlayer {
                    if !player.isPlaying && self.currentTime >= self.duration - 1.0 {
                        print("⚠️ Запасной механизм: трек закончился")
                        self.playNextTrack()
                    }
                }
            }
        }
        
        RunLoop.current.add(timer!, forMode: .common)
    }
    
    // MARK: - Сохранение и загрузка плейлиста
    
    func savePlaylist() {
        do {
            let documentsURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
            let playlistURL = documentsURL.appendingPathComponent("playlist.json")
            
            let data = try JSONEncoder().encode(tracks)
            try data.write(to: playlistURL)
            
            print("✅ Плейлист сохранен")
        } catch {
            print("❌ Ошибка сохранения плейлиста: \(error.localizedDescription)")
        }
    }
    
    func loadPlaylist() {
        do {
            let documentsURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
            let playlistURL = documentsURL.appendingPathComponent("playlist.json")
            
            if FileManager.default.fileExists(atPath: playlistURL.path) {
                let data = try Data(contentsOf: playlistURL)
                tracks = try JSONDecoder().decode([Track].self, from: data)
                
                if !tracks.isEmpty {
                    currentTrackIndex = 0
                    songTitle = tracks[0].name
                    duration = tracks[0].duration
                    updateCurrentArtwork(for: tracks[0])
                }
                
                print("✅ Плейлист загружен: \(tracks.count) треков")
            }
        } catch {
            print("❌ Ошибка загрузки плейлиста: \(error.localizedDescription)")
        }
    }
    
    // MARK: - Remote Control
    
    func setupRemoteTransportControls() {
        let commandCenter = MPRemoteCommandCenter.shared()
        
        commandCenter.playCommand.removeTarget(nil)
        commandCenter.pauseCommand.removeTarget(nil)
        commandCenter.togglePlayPauseCommand.removeTarget(nil)
        commandCenter.changePlaybackPositionCommand.removeTarget(nil)
        commandCenter.nextTrackCommand.removeTarget(nil)
        commandCenter.previousTrackCommand.removeTarget(nil)
        
        commandCenter.playCommand.addTarget { _ in
            self.play()
            return .success
        }
        
        commandCenter.pauseCommand.addTarget { _ in
            self.pause()
            return .success
        }
        
        commandCenter.togglePlayPauseCommand.addTarget { _ in
            self.togglePlayPause()
            return .success
        }
        
        commandCenter.changePlaybackPositionCommand.addTarget { event in
            guard let event = event as? MPChangePlaybackPositionCommandEvent else { return .commandFailed }
            
            self.audioPlayer?.currentTime = event.positionTime
            self.currentTime = event.positionTime
            self.updateNowPlaying()
            
            return .success
        }
        
        commandCenter.nextTrackCommand.addTarget { _ in
            self.playNextTrack()
            return .success
        }
        
        commandCenter.previousTrackCommand.addTarget { _ in
            self.playPreviousTrack()
            return .success
        }
        
        print("✅ Remote Transport Controls настроены")
    }
    
    func updateNowPlaying() {
        var nowPlayingInfo = [String: Any]()
        
        nowPlayingInfo[MPMediaItemPropertyTitle] = songTitle
        nowPlayingInfo[MPMediaItemPropertyArtist] = "CloudPlayer"
        nowPlayingInfo[MPMediaItemPropertyPlaybackDuration] = duration
        nowPlayingInfo[MPNowPlayingInfoPropertyElapsedPlaybackTime] = currentTime
        nowPlayingInfo[MPNowPlayingInfoPropertyPlaybackRate] = isPlaying ? 1.0 : 0.0
        
        if let artwork = createArtwork() {
            nowPlayingInfo[MPMediaItemPropertyArtwork] = artwork
        }
        
        MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo
    }
    
    func createArtwork() -> MPMediaItemArtwork? {
        if let currentArtworkImage {
            return MPMediaItemArtwork(boundsSize: currentArtworkImage.size) { _ in currentArtworkImage }
        }
        
        let config = UIImage.SymbolConfiguration(pointSize: 200, weight: .regular)
        if let image = UIImage(systemName: "music.note", withConfiguration: config)?
            .withTintColor(.systemBlue, renderingMode: .alwaysOriginal) {
            return MPMediaItemArtwork(boundsSize: image.size) { _ in image }
        }
        return nil
    }
    
    private func updateCurrentArtwork(for track: Track) {
        let trackID = track.id
        currentArtworkImage = nil
        
        Task {
            let image = await loadArtworkImage(for: track)
            await MainActor.run {
                guard
                    self.currentTrackIndex < self.tracks.count,
                    self.tracks[self.currentTrackIndex].id == trackID
                else { return }
                self.currentArtworkImage = image
            }
        }
    }
    
    private func loadArtworkImage(for track: Track) async -> UIImage? {
        let fm = FileManager.default
        let audioURL = track.url
        
        let candidates = [
            audioURL.deletingPathExtension().appendingPathExtension("jpg"),
            audioURL.deletingPathExtension().appendingPathExtension("jpeg"),
            audioURL.deletingPathExtension().appendingPathExtension("png")
        ]
        for candidate in candidates where fm.fileExists(atPath: candidate.path) {
            if let image = UIImage(contentsOfFile: candidate.path) {
                return image
            }
        }
        
        let documentsURL = fm.urls(for: .documentDirectory, in: .userDomainMask).first
        let baseName = (track.name as NSString).deletingPathExtension
        if let documentsURL, !baseName.isEmpty {
            let byNameCandidates = [
                documentsURL.appendingPathComponent(baseName).appendingPathExtension("jpg"),
                documentsURL.appendingPathComponent(baseName).appendingPathExtension("jpeg"),
                documentsURL.appendingPathComponent(baseName).appendingPathExtension("png")
            ]
            for candidate in byNameCandidates where fm.fileExists(atPath: candidate.path) {
                if let image = UIImage(contentsOfFile: candidate.path) {
                    return image
                }
            }
        }
        
        if let embeddedImage = await loadEmbeddedArtworkImage(from: audioURL) {
            return embeddedImage
        }
        
        return nil
    }
    
    private func loadEmbeddedArtworkImage(from audioURL: URL) async -> UIImage? {
        let asset = AVURLAsset(url: audioURL)
        guard let metadataItems = try? await asset.load(.commonMetadata) else {
            return nil
        }

        for item in metadataItems where item.commonKey?.rawValue == "artwork" {
            if let dataValue = try? await item.load(.dataValue),
               let image = UIImage(data: dataValue) {
                return image
            }
            
            if let loadedValue = try? await item.load(.value) {
                if let data = loadedValue as? Data, let image = UIImage(data: data) {
                    return image
                }
            }
        }
        
        return nil
    }
    
    private func copySidecarArtworkIfExists(from originalAudioURL: URL, toAudioURL copiedAudioURL: URL) {
        let fm = FileManager.default
        let extensions = ["jpg", "jpeg", "png"]
        
        for ext in extensions {
            let sourceArtworkURL = originalAudioURL.deletingPathExtension().appendingPathExtension(ext)
            guard fm.fileExists(atPath: sourceArtworkURL.path) else { continue }
            
            let destinationArtworkURL = copiedAudioURL.deletingPathExtension().appendingPathExtension(ext)
            do {
                if fm.fileExists(atPath: destinationArtworkURL.path) {
                    try fm.removeItem(at: destinationArtworkURL)
                }
                try fm.copyItem(at: sourceArtworkURL, to: destinationArtworkURL)
                print("✅ Скопирована обложка: \(sourceArtworkURL.lastPathComponent)")
                return
            } catch {
                print("⚠️ Не удалось скопировать обложку \(sourceArtworkURL.lastPathComponent): \(error.localizedDescription)")
            }
        }
    }
    
    // MARK: - Основные функции плеера
    
    func play() {
        // Настраиваем аудиосессию
        setupAudioSession()
        
        audioPlayer?.play()
        isPlaying = true
        startTimer()
        updateNowPlaying()
        print("▶️ Воспроизведение запущено")
    }
    
    func pause() {
        audioPlayer?.pause()
        isPlaying = false
        timer?.invalidate()
        timer = nil
        updateNowPlaying()
        print("⏸ Воспроизведение приостановлено")
    }
    
    func formatTime(_ time: TimeInterval) -> String {
        let minutes = Int(time) / 60
        let seconds = Int(time) % 60
        return String(format: "%d:%02d", minutes, seconds)
    }
}