Package.swift

// swift-tools-version: 6.2
// The swift-tools-version declares the minimum version of Swift required to build this package.

import PackageDescription

let package = Package(
    name: "SamplePackage",
    platforms: [.iOS(.v17)],
    products: [
        .library(
            name: "iOS",
            targets: [
                Targets.ios.name
            ]
        ),
    ],
    dependencies: ExternalPackage.allCases.map { $0.dependency },
    targets: Targets.allCases.map { $0.target }
)

private enum ExternalPackage: CaseIterable {
    case firebase
    case rswift

    private var definition: (name: String, dependency: Package.Dependency) {
        switch self {
        case .firebase:
            (
                name: "firebase-ios-sdk",
                dependency: .package(url: "https://github.com/firebase/firebase-ios-sdk", .upToNextMajor(from: "10.22.0"))
            )
        case .rswift:
            (
                name: "R.swift",
                dependency: .package(url: "https://github.com/mac-cain13/R.swift.git", from: "7.0.0")
            )
        }
    }

    var name: String { definition.name }
    var dependency: Package.Dependency { definition.dependency }
}

private enum Products {
    case firebaseCrashlytics
    case firebaseAnalytics
    case firebaseRemoteConfig
    case rswift

    private var definition: (name: String, package: ExternalPackage) {
        switch self {
        case .firebaseCrashlytics: (name: "FirebaseCrashlytics", package: .firebase)
        case .firebaseAnalytics: (name: "FirebaseAnalytics", package: .firebase)
        case .firebaseRemoteConfig: (name: "FirebaseRemoteConfig", package: .firebase)
        case .rswift: (name: "RswiftLibrary", package: .rswift)
        }
    }

    var name: String { definition.name }
    var package: ExternalPackage { definition.package }
}

private enum Targets: CaseIterable {
    case ios
    case search
    case setting
    case welcome

    private var definition: PackageDescription.Target {
        switch self {
        case .ios: .target(
            name: "iOS",
            dependencies: [
                .product(.firebaseCrashlytics),
                .product(.firebaseAnalytics),
                .product(.firebaseRemoteConfig),
                .target(.search),
                .target(.setting),
                .target(.welcome)
            ]
        )
        case .search: .target(
            name: "Search",
            dependencies: [
                .product(.rswift),
                .product(.firebaseCrashlytics),
                .product(.firebaseAnalytics)
            ],
            plugins: [
                .plugin(.rswiftGenerateInternalResources)
            ]
        )
        case .setting: .target(
            name: "Setting",
            dependencies: [
                .product(.rswift),
                .product(.firebaseCrashlytics),
                .product(.firebaseAnalytics)
            ],
            plugins: [
                .plugin(.rswiftGenerateInternalResources)
            ]
        )
        case .welcome: .target(
            name: "Welcome",
            dependencies: [
                .product(.rswift),
                .product(.firebaseCrashlytics),
                .product(.firebaseAnalytics)
            ],
            plugins: [
                .plugin(.rswiftGenerateInternalResources)
            ]
        )
        }
    }

    var name: String { definition.name }
    var target: PackageDescription.Target { definition }
}

private enum Plugins {
    case rswiftGenerateInternalResources

    private var definition: (name: String, package: ExternalPackage) {
        switch self {
        case .rswiftGenerateInternalResources: (name: "RswiftGenerateInternalResources", package: .rswift)
        }
    }

    var name: String { definition.name }
    var package: ExternalPackage { definition.package }
}

// MARK: - ヘルパー

extension PackageDescription.Target.Dependency {
    fileprivate static func product(_ product: Products) -> Self {
        .product(name: product.name, package: product.package.name)
    }
}

extension PackageDescription.Target.Dependency {
    fileprivate static func target(_ target: Targets) -> Self {
        .target(name: target.name)
    }
}

extension PackageDescription.Target.PluginUsage {
    fileprivate static func plugin(_ plugin: Plugins) -> Self {
        .plugin(name: plugin.name, package: plugin.package.name)
    }
}