/macos/plac/Core/Transport.swift at 030913670c7bab591d4066bf8dcfd099f0e55258

// Copyright 2025 Shota FUJI
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0

import PlacKit
import os

protocol NowPlaying {
	var oneline: String { get }
	var twoline: (String, String?) { get }
	var threeline: (String, String?, String?) { get }

	/// Seek information. The first element represents current seek position and the second represents current song's length.
	/// Both numbers are in seconds, starts from 0.
	var seek: (UInt64, UInt64)? { get }

	var imageKey: String? { get }
}

class CoreNowPlaying: NowPlaying {
	var ptr: UnsafeMutablePointer<PlacKit.plac_transport_now_playing>

	var oneline: String {
		return String(cString: ptr.pointee.one_line_line1)
	}

	var twoline: (String, String?) {
		return (
			String(cString: ptr.pointee.two_line_line1),
			ptr.pointee.two_line_line2.map { String(cString: $0) }
		)
	}

	var threeline: (String, String?, String?) {
		return (
			String(cString: ptr.pointee.three_line_line1),
			ptr.pointee.three_line_line2.map { String(cString: $0) },
			ptr.pointee.three_line_line3.map { String(cString: $0) },
		)
	}

	var seek: (UInt64, UInt64)? {
		if !ptr.pointee.has_length || !ptr.pointee.has_seek_position {
			return nil
		}

		return (ptr.pointee.seek_position, ptr.pointee.length)
	}

	var imageKey: String? {
		return ptr.pointee.image_key.map { String(cString: $0) }
	}

	init(ptr: UnsafeMutablePointer<PlacKit.plac_transport_now_playing>) {
		self.ptr = ptr
	}

	deinit {
		PlacKit.plac_transport_now_playing_release(ptr)
	}
}

class MockNowPlaying: NowPlaying {
	var oneline: String
	var twoline: (String, String?)
	var threeline: (String, String?, String?)

	var seek: (UInt64, UInt64)?
	var imageKey: String?

	init(
		line1: String,
		line2: String? = nil,
		line3: String? = nil,
		seek: (UInt64, UInt64)? = nil,
		imageKey: String? = nil
	) {
		self.oneline = line1
		self.twoline = (line1, line2)
		self.threeline = (line1, line2, line3)

		self.seek = seek
		self.imageKey = imageKey
	}
}

enum PlaybackAction {
	case Next
	case Prev
	case Pause
	case Play
	case Seek
}

protocol Zone {
	var id: String { get }
	var name: String { get }
	var playback: PlacKit.plac_transport_playback_state { get }
	var nowPlaying: NowPlaying? { get }

	func isAllowedTo(_ action: PlaybackAction) -> Bool
}

class CoreZone: Identifiable, Zone {
	var ptr: UnsafeMutablePointer<PlacKit.plac_transport_zone>
	var nowPlaying: (any NowPlaying)?

	var id: String {
		return String(cString: ptr.pointee.id)
	}

	var name: String {
		return String(cString: ptr.pointee.name)
	}

	var playback: PlacKit.plac_transport_playback_state {
		return ptr.pointee.playback
	}

	init(ptr: UnsafeMutablePointer<PlacKit.plac_transport_zone>) {
		self.ptr = ptr
		self.nowPlaying = ptr.pointee.now_playing.map { CoreNowPlaying(ptr: $0) }
	}

	deinit {
		PlacKit.plac_transport_zone_release(ptr)
	}

	func isAllowedTo(_ action: PlaybackAction) -> Bool {
		switch action {
		case .Next:
			return
				(ptr.pointee.allowed_action & UInt16(PlacKit.PLAC_TRANSPORT_ACTION_NEXT))
				!= 0
		case .Prev:
			return
				(ptr.pointee.allowed_action & UInt16(PlacKit.PLAC_TRANSPORT_ACTION_PREV))
				!= 0
		case .Pause:
			return
				(ptr.pointee.allowed_action
				& UInt16(PlacKit.PLAC_TRANSPORT_ACTION_PAUSE)) != 0
		case .Play:
			return
				(ptr.pointee.allowed_action & UInt16(PlacKit.PLAC_TRANSPORT_ACTION_PLAY))
				!= 0
		case .Seek:
			return
				(ptr.pointee.allowed_action & UInt16(PlacKit.PLAC_TRANSPORT_ACTION_SEEK))
				!= 0
		}
	}
}

class MockZone: Identifiable, Zone {
	var id: String
	var name: String
	var playback: plac_transport_playback_state
	var nowPlaying: (any NowPlaying)?
	var allowedActions: [PlaybackAction]

	init(
		id: String,
		name: String,
		playback: plac_transport_playback_state,
		nowPlaying: (any NowPlaying)? = nil,
		allowedActions: [PlaybackAction] = [],
	) {
		self.id = id
		self.name = name
		self.playback = playback
		self.nowPlaying = nowPlaying
		self.allowedActions = allowedActions
	}

	func isAllowedTo(_ action: PlaybackAction) -> Bool {
		return self.allowedActions.firstIndex(of: action) != nil
	}
}

class ZoneListEvent {
	let logger = Logger()

	var ptr: UnsafeMutablePointer<PlacKit.plac_transport_zone_list_event>

	var addedZones: [CoreZone]
	var changedZones: [CoreZone]
	var removedZoneIds: [String]

	init(ptr: UnsafeMutablePointer<PlacKit.plac_transport_zone_list_event>) {
		self.ptr = ptr

		self.addedZones = []
		if ptr.pointee.added_zones_len > 0 {
			var addedZones: [CoreZone] = []

			for i in 0..<ptr.pointee.added_zones_len {
				addedZones.append(
					CoreZone(
						ptr: PlacKit.plac_transport_zone_retain(
							ptr.pointee.added_zones_ptr[i]
						)
					)
				)
			}

			self.addedZones = addedZones
		}

		self.changedZones = []
		if ptr.pointee.changed_zones_len > 0 {
			var changedZones: [CoreZone] = []

			for i in 0..<ptr.pointee.changed_zones_len {
				changedZones.append(
					CoreZone(
						ptr: PlacKit.plac_transport_zone_retain(
							ptr.pointee.changed_zones_ptr[i]
						)
					)
				)
			}

			self.changedZones = changedZones
		}

		self.removedZoneIds = []
		if ptr.pointee.removed_zone_ids_len > 0 {
			var removedZoneIds: [String] = []

			for i in 0..<ptr.pointee.removed_zone_ids_len {
				if let strPtr = ptr.pointee.removed_zone_ids_ptr[i] {
					removedZoneIds.append(String(cString: strPtr))
				} else {
					logger.warning("removed_zone_ids_ptr[\(i)] is null pointer")
				}
			}

			self.removedZoneIds = removedZoneIds
		}
	}

	deinit {
		PlacKit.plac_transport_zone_list_event_release(ptr)
	}
}