kplayer/kplayer/photo/SPhotoModel.swift

//
// Created by Marco Schmickler on 22.06.22.
// Copyright (c) 2022 Marco Schmickler. All rights reserved.
//

import Foundation
import SwiftUI

class SPhotoModel : ObservableObject {
    @Published var folderItems = [MediaItem]()
    @Published var folderIndex = 0

    @Published var compilationItems : [MediaItem]
    @Published var allItems : [MediaItem]
    @Published var indexItems : [MediaItem]
    @Published var selectedItem : MediaItem
    @Published var index = 0
    @Published var thumbIndex = 0
    @Published var scrub = false
    @Published var favorite = false
    @Published var dirty = false
    @Published var compilation = false
    @Published var preloading = 0
    @Published var go = false
    @Published var locked = false
    @Published var deadline = Date()
    @Published var image = UIImage()

    @Published var scale: CGFloat = 1.0
    @Published var maxScale: CGFloat = 1.0
    @Published var dragOffset: CGSize = CGSize.zero
    @Published var spring = false
    @Published var timer : Timer?

    init(allItems: [MediaItem]) {
        self.allItems = allItems
        self.compilationItems = allItems
        selectedItem = allItems[0]
        indexItems = allItems
        update(allItems: allItems)
    }

    func loadImage() {
        if selectedItem.thumbUrl != nil {
            loadImage(for: selectedItem.imageUrlAbsolute)
        }
    }

    func loadImage(for urlString: String) {
        guard let url = URL(string: urlString) else { return }

        if (!go) {
            if let thumb = ImageLoader.shared.cache[url] {
                image = thumb

                print("cache \(url)")
            }
        }
        if let t = timer {
            t.invalidate()
        }
        timer = Timer.scheduledTimer(withTimeInterval: 0.1, repeats: false) { timer in

            print("load \(urlString)")

            ImageLoader.shared.loadFullImage(from: url).sink { img in
                if let i = img {
                    if self.go || self.selectedItem.imageUrlAbsolute == url.absoluteString {
                        Thread.sleep(until: self.deadline)
                        self.image = i
                    }

                    if (self.go) {
                        self.nextItem()
                    }
                }
            }
        }

//        let task = URLSession.shared.dataTask(with: url) { data, response, error in
//            guard let data = data else { return }
//            DispatchQueue.main.async {
//                self.image = UIImage(data: data) ?? UIImage(systemName: "repeat")!
//                print("loaded \(urlString)\(self.image)")
//            }
//        }
//        task.resume()
    }

    private func update(allItems: [MediaItem]) {
        if allItems.isEmpty {
            return
        }

        self.allItems = allItems
        selectedItem = allItems[0]

        let max = 17

        if allItems.count < max {
            indexItems = allItems
        }
        else {
            indexItems = [MediaItem]()
            var nj = -1
            for i in 0...allItems.count-1 {
                allItems[i].indexId = i
                let j = Int((Double(i) / Double(allItems.count)) * 17.0)
                if j > nj {
                    nj = j
                    indexItems.append(allItems[i])
                }
            }
        }

        let m = MediaItem(name: selectedItem.name, path: selectedItem.path, root: selectedItem.root, type: selectedItem.type)
        m.children = allItems

        DatabaseManager.sharedInstance.enrichItem(m)

        selectedItem.indexId = 0
        loadImage()
    }

    func selectItem(_ item: MediaItem) {
        if let thumb = item.thumbUrl {
            for i in 0...allItems.count - 1 {
                if allItems[i].thumbUrl != nil && allItems[i].thumbUrl! == thumb {
                    selectedItem = item
                    selectedItem.indexId = i
                    index = i
                    loadImage()

                    break;
                }
            }
        }
    }

    func back() {
        if locked {
            return
        }
        locked = true

        if (folderIndex > 0) {
            folderIndex -= 1
        } else {
            folderIndex = folderItems.count - 1
        }
        show()
    }

    func next() {
        if locked {
            return
        }
        locked = true

        if (folderIndex < folderItems.count - 1) {
            folderIndex += 1
        } else {
            folderIndex = 0
        }
        show()
    }

    func nextItem() {
        if (index < allItems.count - 1) {
            index += 1
        }
        else {
            index = 0
        }

        selectedItem = allItems[index]
        deadline = Date().advanced(by: 0.4)
        loadImage()
    }

    func show() {
        if (compilation) {
            if folderIndex == 0 {
                update(allItems: compilationItems)
                locked = false
                return
            }
            else {
                folderIndex = 1
            }
        }

        if folderIndex > folderItems.count - 1 {
            return
        }
        
        var selectedItem = compilation ? selectedItem : folderItems[folderIndex]

        NetworkManager.sharedInstance.loadPicDetails(items: selectedItem, result: { (im: [MediaItem]) in
            self.index = 0
            self.update(allItems: im)
            self.preload()

            let kitem = DatabaseManager.sharedInstance.getKItem(selectedItem)
            self.favorite = kitem.favorite

            Timer.scheduledTimer(withTimeInterval: 1, repeats: false) { timer in
                self.locked = false
            }
        })
    }

    func preload() {
        preloading = 0
        for item in allItems {
            if item.thumbImage == nil && item.thumbUrlAbsolute.contains("/ren/thumbs/"){
                if let URL = Foundation.URL(string: item.thumbUrlAbsolute) {
                    //try! await Task.sleep(nanoseconds: UInt64(1 * Double(NSEC_PER_SEC)))
                    print("preload \(item.thumbUrlAbsolute)")
                    preloading += 1
                    ImageLoader.shared.loadImageBackground(from: URL).sink { image in
                        if let i = image {
                            item.thumbImage = i
                        }
                        self.preloading -= 1
                    }
                    // break
                }
            }
        }
    }
}