mirror of
https://github.com/yattee/yattee.git
synced 2024-12-14 22:30:32 +05:30
208 lines
5.2 KiB
Swift
208 lines
5.2 KiB
Swift
import Alamofire
|
|
import AVKit
|
|
import Foundation
|
|
import SwiftUI
|
|
import SwiftyJSON
|
|
|
|
struct Video: Identifiable, Equatable, Hashable {
|
|
enum VideoID {
|
|
static func isValid(_ id: Video.ID) -> Bool {
|
|
id.count == 11
|
|
}
|
|
}
|
|
|
|
let id: String
|
|
let videoID: String
|
|
var title: String
|
|
var thumbnails: [Thumbnail]
|
|
var author: String
|
|
var length: TimeInterval
|
|
var published: String
|
|
var views: Int
|
|
var description: String?
|
|
var genre: String?
|
|
|
|
// index used when in the Playlist
|
|
var indexID: String?
|
|
|
|
var live: Bool
|
|
var upcoming: Bool
|
|
|
|
var streams = [Stream]()
|
|
|
|
var publishedAt: Date?
|
|
var likes: Int?
|
|
var dislikes: Int?
|
|
var keywords = [String]()
|
|
|
|
var channel: Channel
|
|
|
|
var related = [Video]()
|
|
var chapters = [Chapter]()
|
|
|
|
var captions = [Captions]()
|
|
|
|
init(
|
|
id: String? = nil,
|
|
videoID: String,
|
|
title: String = "",
|
|
author: String = "",
|
|
length: TimeInterval = .zero,
|
|
published: String = "",
|
|
views: Int = 0,
|
|
description: String? = nil,
|
|
genre: String? = nil,
|
|
channel: Channel = .init(id: "", name: ""),
|
|
thumbnails: [Thumbnail] = [],
|
|
indexID: String? = nil,
|
|
live: Bool = false,
|
|
upcoming: Bool = false,
|
|
publishedAt: Date? = nil,
|
|
likes: Int? = nil,
|
|
dislikes: Int? = nil,
|
|
keywords: [String] = [],
|
|
streams: [Stream] = [],
|
|
related: [Video] = [],
|
|
chapters: [Chapter] = [],
|
|
captions: [Captions] = []
|
|
) {
|
|
self.id = id ?? UUID().uuidString
|
|
self.videoID = videoID
|
|
self.title = title
|
|
self.author = author
|
|
self.length = length
|
|
self.published = published
|
|
self.views = views
|
|
self.description = description
|
|
self.genre = genre
|
|
self.channel = channel
|
|
self.thumbnails = thumbnails
|
|
self.indexID = indexID
|
|
self.live = live
|
|
self.upcoming = upcoming
|
|
self.publishedAt = publishedAt
|
|
self.likes = likes
|
|
self.dislikes = dislikes
|
|
self.keywords = keywords
|
|
self.streams = streams
|
|
self.related = related
|
|
self.chapters = chapters
|
|
self.captions = captions
|
|
}
|
|
|
|
static func local(_ url: URL) -> Video {
|
|
Video(
|
|
videoID: url.absoluteString,
|
|
streams: [.init(localURL: url)]
|
|
)
|
|
}
|
|
|
|
var isLocal: Bool {
|
|
!VideoID.isValid(videoID)
|
|
}
|
|
|
|
var displayTitle: String {
|
|
if isLocal {
|
|
return localStreamFileName ?? localStream?.description ?? title
|
|
}
|
|
|
|
return title
|
|
}
|
|
|
|
var displayAuthor: String {
|
|
if isLocal, localStreamIsRemoteURL {
|
|
return remoteUrlHost ?? "Unknown"
|
|
}
|
|
|
|
return author
|
|
}
|
|
|
|
var publishedDate: String? {
|
|
(published.isEmpty || published == "0 seconds ago") ? nil : published
|
|
}
|
|
|
|
var viewsCount: String? {
|
|
views != 0 ? views.formattedAsAbbreviation() : nil
|
|
}
|
|
|
|
var likesCount: String? {
|
|
guard (likes ?? 0) > 0 else {
|
|
return nil
|
|
}
|
|
|
|
return likes?.formattedAsAbbreviation()
|
|
}
|
|
|
|
var dislikesCount: String? {
|
|
guard (dislikes ?? 0) > 0 else {
|
|
return nil
|
|
}
|
|
|
|
return dislikes?.formattedAsAbbreviation()
|
|
}
|
|
|
|
func thumbnailURL(quality: Thumbnail.Quality) -> URL? {
|
|
thumbnails.first { $0.quality == quality }?.url
|
|
}
|
|
|
|
static func == (lhs: Video, rhs: Video) -> Bool {
|
|
let videoIDIsEqual = lhs.videoID == rhs.videoID
|
|
|
|
if !lhs.indexID.isNil, !rhs.indexID.isNil {
|
|
return videoIDIsEqual && lhs.indexID == rhs.indexID
|
|
}
|
|
|
|
return videoIDIsEqual
|
|
}
|
|
|
|
func hash(into hasher: inout Hasher) {
|
|
hasher.combine(id)
|
|
}
|
|
|
|
var watchFetchRequest: FetchRequest<Watch> {
|
|
FetchRequest<Watch>(
|
|
entity: Watch.entity(),
|
|
sortDescriptors: [],
|
|
predicate: NSPredicate(format: "videoID = %@", videoID)
|
|
)
|
|
}
|
|
|
|
var localStream: Stream? {
|
|
guard isLocal else { return nil }
|
|
return streams.first
|
|
}
|
|
|
|
var localStreamIsFile: Bool {
|
|
guard let localStream else { return false }
|
|
return localStream.localURL.isFileURL
|
|
}
|
|
|
|
var localStreamIsRemoteURL: Bool {
|
|
guard let localStream else { return false }
|
|
return !localStream.localURL.isFileURL
|
|
}
|
|
|
|
var remoteUrlHost: String? {
|
|
localStreamURLComponents?.host
|
|
}
|
|
|
|
var localStreamFileName: String? {
|
|
guard let path = localStream?.localURL?.lastPathComponent else { return nil }
|
|
|
|
if let localStreamFileExtension {
|
|
return String(path.dropLast(localStreamFileExtension.count + 1))
|
|
}
|
|
return String(path)
|
|
}
|
|
|
|
var localStreamFileExtension: String? {
|
|
guard let path = localStreamURLComponents?.path else { return nil }
|
|
return path.contains(".") ? path.components(separatedBy: ".").last?.uppercased() : nil
|
|
}
|
|
|
|
private var localStreamURLComponents: URLComponents? {
|
|
guard let localStream else { return nil }
|
|
return URLComponents(url: localStream.localURL, resolvingAgainstBaseURL: false)
|
|
}
|
|
}
|