Fastfile

# This file contains the fastlane.tools configuration
# You can find the documentation at https://docs.fastlane.tools
#
# For a list of all available actions, check out
#
#     https://docs.fastlane.tools/actions
#
# For a list of all available plugins, check out
#
#     https://docs.fastlane.tools/plugins/available-plugins
#

default_platform(:ios)

TEAMID = ENV["TEAMID"]
GH_PAT = ENV["GH_PAT"]
GITHUB_WORKSPACE = ENV["GITHUB_WORKSPACE"]
GITHUB_REPOSITORY_OWNER = ENV["GITHUB_REPOSITORY_OWNER"]
FASTLANE_KEY_ID = ENV["FASTLANE_KEY_ID"]
FASTLANE_ISSUER_ID = ENV["FASTLANE_ISSUER_ID"]
FASTLANE_KEY = ENV["FASTLANE_KEY"]
DEVICE_NAME = ENV["DEVICE_NAME"]
DEVICE_ID = ENV["DEVICE_ID"]
ENV["FASTLANE_XCODEBUILD_SETTINGS_TIMEOUT"] = "120"
TEAMID_SUFFIX = ENV["TEAMID_SUFFIX"].to_s.empty? ? "" : ".#{ENV["TEAMID_SUFFIX"]}"


platform :ios do
  desc "Build Loop"
  lane :build_loop do
    setup_ci if ENV['CI']
    
    update_project_team(
      path: "#{GITHUB_WORKSPACE}/Loop/Loop.xcodeproj",
      teamid: "#{TEAMID}"
    )

    api_key = app_store_connect_api_key(
      key_id: "#{FASTLANE_KEY_ID}",
      issuer_id: "#{FASTLANE_ISSUER_ID}",
      key_content: "#{FASTLANE_KEY}"
    )

    previous_build_number = latest_testflight_build_number(
      app_identifier: "com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop",
      api_key: api_key,
    )

    current_build_number = previous_build_number + 1

    increment_build_number(
      xcodeproj: "#{GITHUB_WORKSPACE}/Loop/Loop.xcodeproj",
      build_number: current_build_number
    )      
    
    match(
      type: "appstore",
      git_basic_authorization: Base64.strict_encode64("#{GITHUB_REPOSITORY_OWNER}:#{GH_PAT}"),
      app_identifier: [
        "com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop", 
        "com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop.statuswidget", 
        "com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop.LoopWatch.watchkitextension", 
        "com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop.LoopWatch", 
        "com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop.Loop-Intent-Extension",
        "com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop.LoopWidgetExtension"
      ]
    )

    mapping = Actions.lane_context[
      SharedValues::MATCH_PROVISIONING_PROFILE_MAPPING
    ]

    update_code_signing_settings(
      path: "#{GITHUB_WORKSPACE}/Loop/Loop.xcodeproj",
      profile_name: mapping["com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop"],
      code_sign_identity: "iPhone Distribution",
      targets: ["Loop"]
    )

    update_code_signing_settings(
      path: "#{GITHUB_WORKSPACE}/Loop/Loop.xcodeproj",
      code_sign_identity: "iPhone Distribution",
      targets: ["LoopCore", "LoopCore-watchOS", "LoopUI"]
    )

    update_code_signing_settings(
      path: "#{GITHUB_WORKSPACE}/Loop/Loop.xcodeproj",
      profile_name: mapping["com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop.statuswidget"],
      code_sign_identity: "iPhone Distribution",
      targets: ["Loop Status Extension"]
    )
    
    update_code_signing_settings(
      path: "#{GITHUB_WORKSPACE}/Loop/Loop.xcodeproj",
      profile_name: mapping["com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop.LoopWatch.watchkitextension"],
      code_sign_identity: "iPhone Distribution",
      targets: ["WatchApp Extension"]
    )
    
    update_code_signing_settings(
      path: "#{GITHUB_WORKSPACE}/Loop/Loop.xcodeproj",
      profile_name: mapping["com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop.LoopWatch"],
      code_sign_identity: "iPhone Distribution",
      targets: ["WatchApp"]
    )
    
    update_code_signing_settings(
      path: "#{GITHUB_WORKSPACE}/Loop/Loop.xcodeproj",
      profile_name: mapping["com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop.Loop-Intent-Extension"],
      code_sign_identity: "iPhone Distribution",
      targets: ["Loop Intent Extension"]
    )
    
    update_code_signing_settings(
      path: "#{GITHUB_WORKSPACE}/Loop/Loop.xcodeproj",
      profile_name: mapping["com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop.LoopWidgetExtension"],
      code_sign_identity: "iPhone Distribution",
      targets: ["Loop Widget Extension"]
    )

    gym(
      export_method: "app-store",
      scheme: "LoopWorkspace",
      output_name: "Loop.ipa",
      configuration: "Release",
      destination: 'generic/platform=iOS',
      buildlog_path: 'buildlog'
    )

    copy_artifacts(
      target_path: "artifacts",
      artifacts: ["*.mobileprovision", "*.ipa", "*.dSYM.zip"]
    )
  end

  desc "Push to TestFlight"
  lane :release do
    api_key = app_store_connect_api_key(
      key_id: "#{FASTLANE_KEY_ID}",
      issuer_id: "#{FASTLANE_ISSUER_ID}",
      key_content: "#{FASTLANE_KEY}"
    )
    
    upload_to_testflight(
      api_key: api_key,
      skip_submission: false,
      ipa: "Loop.ipa",
      skip_waiting_for_build_processing: true,
    )
  end

  desc "Provision Identifiers and Certificates"
  lane :identifiers do
    setup_ci if ENV['CI']
    ENV["MATCH_READONLY"] = false.to_s
    
    app_store_connect_api_key(
      key_id: "#{FASTLANE_KEY_ID}",
      issuer_id: "#{FASTLANE_ISSUER_ID}",
      key_content: "#{FASTLANE_KEY}"
    )

    def configure_bundle_id(name, identifier, capabilities)
      bundle_id = Spaceship::ConnectAPI::BundleId.find(identifier) || Spaceship::ConnectAPI::BundleId.create(
        name:       name,
        identifier: identifier,
        platform:   "IOS"
      )
      existing = bundle_id.get_capabilities.map(&:capability_type)
      capabilities.reject { |c| existing.include?(c) }.each do |cap|
        bundle_id.create_capability(cap)
      end
    end

    configure_bundle_id("Loop", "com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop", [
      Spaceship::ConnectAPI::BundleIdCapability::Type::APP_GROUPS,
      Spaceship::ConnectAPI::BundleIdCapability::Type::HEALTHKIT,
      Spaceship::ConnectAPI::BundleIdCapability::Type::PUSH_NOTIFICATIONS,
      Spaceship::ConnectAPI::BundleIdCapability::Type::SIRIKIT,
      Spaceship::ConnectAPI::BundleIdCapability::Type::NFC_TAG_READING
    ])

    configure_bundle_id("Loop Intent Extension", "com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop.Loop-Intent-Extension", [
      Spaceship::ConnectAPI::BundleIdCapability::Type::APP_GROUPS
    ])

    configure_bundle_id("Loop Status Extension", "com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop.statuswidget", [
      Spaceship::ConnectAPI::BundleIdCapability::Type::APP_GROUPS
    ])

    configure_bundle_id("WatchApp", "com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop.LoopWatch", [])

    configure_bundle_id("WatchApp Extension", "com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop.LoopWatch.watchkitextension", [
      Spaceship::ConnectAPI::BundleIdCapability::Type::HEALTHKIT,
      Spaceship::ConnectAPI::BundleIdCapability::Type::SIRIKIT
    ])

    configure_bundle_id("Loop Widget Extension", "com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop.LoopWidgetExtension", [
      Spaceship::ConnectAPI::BundleIdCapability::Type::APP_GROUPS
    ])
    
  end

  desc "Provision Certificates"
  lane :certs do
    setup_ci if ENV['CI']
    ENV["MATCH_READONLY"] = false.to_s
    
    app_store_connect_api_key(
      key_id: "#{FASTLANE_KEY_ID}",
      issuer_id: "#{FASTLANE_ISSUER_ID}",
      key_content: "#{FASTLANE_KEY}"
    )
    
    match(
      type: "appstore",
      force: false,
      verbose: true,
      git_basic_authorization: Base64.strict_encode64("#{GITHUB_REPOSITORY_OWNER}:#{GH_PAT}"),
      app_identifier: [
        "com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop", 
        "com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop.statuswidget", 
        "com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop.LoopWatch.watchkitextension", 
        "com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop.LoopWatch", 
        "com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop.Loop-Intent-Extension",
        "com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop.LoopWidgetExtension",
      ]
    )
  end

  desc "Validate Secrets"
  lane :validate_secrets do
    setup_ci if ENV['CI']
    ENV["MATCH_READONLY"] = true.to_s
    
    app_store_connect_api_key(
      key_id: "#{FASTLANE_KEY_ID}",
      issuer_id: "#{FASTLANE_ISSUER_ID}",
      key_content: "#{FASTLANE_KEY}"
    )
    
    def find_bundle_id(identifier)
      bundle_id = Spaceship::ConnectAPI::BundleId.find(identifier)
    end

    find_bundle_id("com.#{TEAMID}#{TEAMID_SUFFIX}.loopkit.Loop")

    match(
      type: "appstore",
      git_basic_authorization: Base64.strict_encode64("#{GITHUB_REPOSITORY_OWNER}:#{GH_PAT}"),
      app_identifier: [],
    )

  end
  
  desc "Nuke Certs"
  lane :nuke_certs do
    setup_ci if ENV['CI']
    ENV["MATCH_READONLY"] = false.to_s
    
    app_store_connect_api_key(
      key_id: "#{FASTLANE_KEY_ID}",
      issuer_id: "#{FASTLANE_ISSUER_ID}",
      key_content: "#{FASTLANE_KEY}"
    )
    
    match_nuke(
      type: "appstore",
      team_id: "#{TEAMID}",
      skip_confirmation: true,
      git_basic_authorization: Base64.strict_encode64("#{GITHUB_REPOSITORY_OWNER}:#{GH_PAT}")
    )
  end

  desc "Check Certificates and Trigger Workflow for Expired or Missing Certificates"
  lane :check_and_renew_certificates do
    setup_ci if ENV['CI']
    ENV["MATCH_READONLY"] = false.to_s

    # Authenticate using App Store Connect API Key
    api_key = app_store_connect_api_key(
      key_id: ENV["FASTLANE_KEY_ID"],
      issuer_id: ENV["FASTLANE_ISSUER_ID"],
      key_content: ENV["FASTLANE_KEY"] # Ensure valid key content
    )

    # Initialize flag to track if renewal of certificates is needed
    new_certificate_needed = false

    # Fetch all certificates
    certificates = Spaceship::ConnectAPI::Certificate.all

    # Filter for Distribution Certificates
    distribution_certs = certificates.select { |cert| cert.certificate_type == "DISTRIBUTION" }

    # Handle case where no distribution certificates are found
    if distribution_certs.empty?
      puts "No Distribution certificates found! Triggering action to create certificate."
      new_certificate_needed = true
    else
      # Check for expiration
      distribution_certs.each do |cert|
        expiration_date = Time.parse(cert.expiration_date)

        puts "Current Distribution Certificate: #{cert.id}, Expiration date: #{expiration_date}"

        if expiration_date < Time.now
          puts "Distribution Certificate #{cert.id} is expired! Triggering action to renew certificate."
          new_certificate_needed = true
        else
          puts "Distribution certificate #{cert.id} is valid. No action required."
        end
      end
    end

    # Write result to new_certificate_needed.txt
    file_path = File.expand_path('new_certificate_needed.txt')
    File.write(file_path, new_certificate_needed ? 'true' : 'false')  

    # Log the absolute path and contents of the new_certificate_needed.txt file
    puts ""
    puts "Absolute path of new_certificate_needed.txt: #{file_path}"
    new_certificate_needed_content = File.read(file_path)
    puts "Certificate creation or renewal needed: #{new_certificate_needed_content}"
  end
end