/macos/Plac/DataModels/ConnectionDataModel.swift at 4bb6f62a011e24c72119b7b5e95dc2e29f0d63f4

// 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 Foundation
import Network
import OSLog
import RoonKit
import SwiftUI

enum CancelError: Error {
	case cancelled
}

enum ConnectionState {
	case connecting
	case connected(Communicatable & Connectable)
	case waitingToReconnect
	case failed(any Error)
}

#if os(macOS)
	let systemName = "macOS"
#else
	let systemName = UIDevice.current.systemName
#endif

@MainActor
@Observable
final class ConnectionDataModel {
	private static let reconnectionWindow: ContinuousClock.Instant.Duration =
		.seconds(5)

	private(set) var state: ConnectionState = .connecting

	@ObservationIgnored
	private var loop: Task<Void, Never>? = nil

	let serverID: String
	let host: String
	let port: UInt16

	private var token: String? = nil

	/// Initialize data model with resolved server.
	convenience init(
		server: Server,
		onConnect: ((_ token: String) -> Void)? = nil
	) {
		self.init(
			serverID: server.id,
			host: server.host,
			port: server.port,
			onConnect: onConnect
		)
	}

	convenience init(
		_ other: ConnectionDataModel,
		onConnect: ((_ token: String) -> Void)? = nil
	) {
		self.init(
			serverID: other.serverID,
			host: other.host,
			port: other.port,
			token: other.token,
			onConnect: onConnect
		)
	}

	init(cancelling: ConnectionDataModel) {
		self.serverID = cancelling.serverID
		self.host = cancelling.host
		self.port = cancelling.port
		self.token = cancelling.token
		self.state = .failed(CancelError.cancelled)
	}

	#if DEBUG
		/// To prevent I/O in Xcode Preview environment.
		init(failingWith: CancelError) {
			self.serverID = ""
			self.host = ""
			self.port = 0
			self.state = .failed(failingWith)
		}
	#endif

	init(
		serverID: String,
		host: String,
		port: UInt16,
		token: String? = nil,
		onConnect: ((_ token: String) -> Void)? = nil
	) {
		self.serverID = serverID
		self.host = host
		self.port = port
		self.loop = Task { [weak self] in
			while true {
				do {

					self?.state = .connecting

					let ext = RegistryService.Extension(
						id: "jp.pocka.plac.apple",
						displayName: "Plac for \(systemName)",
						version: "0.0.1",
						publisher: "Shota FUJI",
						email: "pockawoooh@gmail.com",
						requiredServices: [
							TransportService.id, BrowseService.id, ImageService.id,
						],
						token: token,
					)

					let conn = try await Connection(
						id: serverID,
						host: host,
						port: port,
						ext: ext
					)

					self?.state = .connected(conn)

					let connectionStartsAt = ContinuousClock.now

					let token = await conn.token

					self?.token = token
					if let token = token {
						onConnect?(token)
					}

					await conn.lifetime()

					let connectionEndsAt = ContinuousClock.now

					if let self = self {
						state = .waitingToReconnect
					}

					Logger().debug("Connection closed, reconnecting after interval")

					try await Task.sleep(
						for: Self.reconnectionWindow
							- (connectionEndsAt - connectionStartsAt)
					)
				} catch {
					switch error {
					// These error happens when a target server is down.
					// This does not catch ETIMEDOUT; we don't want our app to
					// unnecessarily access network interface. Most of the time
					// that error code returned, is server being down or rebooting.
					case Connection.ConnectError.connectionNotReady(
						NWError.posix(.ECONNREFUSED)
					),
						Connection.ConnectError.connectionNotReady(
							NWError.posix(.ECONNABORTED)
						):
						Logger().info("Connection refused, retrying after 3 seconds")

						if let self = self {
							state = .waitingToReconnect
						}

						do {
							try await Task.sleep(for: .seconds(3))
							continue
						} catch {
							// Abort loop on cancellation
							return
						}
					default:
						Logger().warning("Connection error: \(error)")
						if let self = self {
							state = .failed(error)
						}
					}

					return
				}
			}
		}
	}

	deinit {
		Logger().debug("Deinitializing ConnectionDataModel")

		if let loop = self.loop {
			loop.cancel()
		}
	}

	func imageURL(req: ImageService.GetRequest) -> URL? {
		URL(roonImage: req, host: host, port: port)
	}
}