// Example function to read values from local.properties in a build.gradle.kts file
fun readLocalProperty(key: String): String? {
    val localPropertiesFile = File(rootDir, "local.properties")
    if (localPropertiesFile.exists()) {
        val properties = Properties()
        localPropertiesFile.inputStream().use { properties.load(it) }
        return properties.getProperty(key)
    }
    return null
}

repositories {
    maven {
        setUrl("https://maven.pkg.github.com/indicio-tech/holdr-sdk-release")
        credentials {
            username = readLocalProperty("githubUsername")
            password = readLocalProperty("githubToken")
        }
    }
    maven {
        setUrl("https://maven.pkg.github.com/LF-Decentralized-Trust-labs/aries-uniffi-wrappers")
        credentials {
            username = readLocalProperty("githubUsername")
            password = readLocalProperty("githubToken")
        }
    }
}

dependencies {
    implementation("tech.indicio:holdr:1.1")
}

<manifest>
    <uses-permission android:name="android.permission.  READ_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.  WRITE_EXTERNAL_STORAGE" />
        <!-- For Android 10 (API level 29) and above -->
    <uses-permission android:name="android.permission.  MANAGE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.INTERNET" />
</manifest>

"dependencies": {
    "@holdr/react-native": "file:holdr-react-native-v1.1.0.tgz",
    "@holdr/core": "file:holdr-core-v1.1.0.tgz",
}

buildscript {
    ext {
        minSdkVersion = 24
    }
}   
allprojects{
    repositories{
        maven {
            setUrl("https://maven.pkg.github.com/indicio-tech/holdr-sdk-release")
            credentials {
                username = readLocalProperty("githubUsername")
                password = readLocalProperty("githubToken")
            }
        }
        maven {
            setUrl("https://maven.pkg.github.com/LF-Decentralized-Trust-labs/aries-uniffi-wrappers")
            credentials {
                username = readLocalProperty("githubUsername")
                password = readLocalProperty("githubToken")
            }
        }
    }
}

target 'ExampleApp' do
    <!-- Other configs -->
+   pod 'rtn-proven-mobile-sdk', :path => '../node_modules/@holdr/react-native'

    target 'ExampleAppTests' do

        <!-- Other configs -->

<!-- Other configs -->
+include ':holdr-react-native
+project(':holdr-react-native').projectDir = new File(rootProject.projectDir, '../node_modules/@holdr/react-native/android')

dependencies{
    <!-- Other dependencies -->
+    implementation project(":holdr-react-native")
}

// If you have other libraries that use libc++_shared.so or libfbjni.so
// you may need to add the following to your android configs
android{
    <!-- Other configs -->
+    packagingOptions {
+        pickFirst '**/libc++_shared.so'
+        pickFirst '**/libfbjni.so'
+    }
}

+ import com.rtnprovenmobilesdk.ProvenMobilePackage;

public class MainApplication extends Application implements ReactApplication {
   
    private final ReactNativeHost mReactNativeHost =
        new ReactNativeHost(this) {
        @Override
        public boolean getUseDeveloperSupport() {
            return BuildConfig.DEBUG;
        }
        @Override
        protected List<ReactPackage> getPackages() {
        @SuppressWarnings("UnnecessaryLocalVariable")
        List<ReactPackage> packages = new PackageList(this).getPackages();
+       packages.add(new ProvenMobilePackage());
        return packages;
        }

val walletConfig: WalletConfig = WalletConfig(
    uri = "sqlite://pathWhereYouWantDataStored/local.db",
    // options are raw(raw random key), kdf:argon2i(Encrypted Key), none(testing only)
    keyMethod = "raw",
    // Should be randomly generated or derived from a pin or password, must be able to be repeatedly accessed
    passkey = "TheActualKeyThatUnlocksTheWallet",
    id = "Unique id for this wallet"
)

let walletConfig = WalletConfig(
    uri: "sqlite://pathWhereYouWantDataStored/local.db",
    keyMethod: "raw",
    passkey: "TheActualKeyThatUnlocksTheWallet",
    id: "Unique id for this wallet"
)

val mediationConfig: MediationConfig = MediationConfig(  
    mediatorInvitationUrl = "Mediation connection url for the default mediator you want to use",
    // Optional parameter to indicate how often, in milliseconds,the Agent should try to reconnect to the mediator
    baseMediatorReconnectionIntervalMS = 500,
    // Optional parameter to indicate the max amount of time between attempts to contact the mediator
    maximumMediatorReconnectionIntervalMS: Int = 10000
)

let mediationConfig = MediationConfig(
    mediatorInvitationUrl: "Mediation connection URL for the default mediator you want to use",
    // Optional parameter to indicate how often, in milliseconds, the Agent should try to reconnect to the mediator
    baseMediatorReconnectionIntervalMS: 500,
    // Optional parameter to indicate the max amount of time between attempts to contact the mediator
    maximumMediatorReconnectionIntervalMS: 10000
)

  val indicioDemoNet = IndyVDRPoolConfig.fromUrl(
        genesisUrl = "https://raw.githubusercontent.com/Indicio-tech/indicio-network/main/genesis_files/pool_transactions_demonet_genesis",
        isProduction = false,
        indyNamespace = "indicio-demo-net"
    )

let indicioDemoNet = IndyVDRPoolConfig.companion.fromUrl(
        genesisUrl = "https://raw.githubusercontent.com/Indicio-tech/indicio-network/main/genesis_files/pool_transactions_demonet_genesis",
        isProduction = false,
        indyNamespace = "indicio-demo-net"
    )

val agent: Agent = Agent(
    license: licenseString, // SDK license as a string
    walletConfig = walletConfig,
    mediationConfig = mediationConfig, // Set to null if you do not need didcomm
    pools = ListOf(
        indicioDemoNet
    ),
    pickupBatchSize = 10, // max number of message that can be picked up at once from the mediator
    defaultConnectionLabel = "Proven SDK", // The label the Agent will use in didComm communication
    enableLogging = false,
    autoAcceptConnections = true,
    autoAcceptCredentials = false,
    customLogger = null // (message: String)->Unit Callback to use for logging instead of `println()`
)

let agent = Agent(
    license: licenseString, // SDK license as a string
    walletConfig: walletConfig,
    mediationConfig: mediationConfig, // Set to nil if not using didcomm
    pools: [
        indicioDemoNet
    ],
    pickupBatchSize: 10, // max number of message that can be picked up at once from the mediator
    defaultConnectionLabel: "Proven SDK", // The label the Agent will use in didComm communication
    enableLogging: false,
    autoAcceptConnections: true,
    autoAcceptCredentials: false,
    customLogger: nil // (message: String)->Void Callback to use for logging instead of `println()`
)

// Start agent (KMPNativeCoroutines)
try await asyncFunction(for: agent.start(startUpTimeout: 10000))

// Start agent (Completion handler)
agent.start(startUpTimeout: 10000){error in
    if(error != nil){
        // Handle error
    }
    // Code to be called when agent started
}

// Start agent (Without KMPNativeCoroutines)
let error: ProvenError? = await agent.start(startUpTimeout: 10000)
if(error != nil){
    // Handle error
}

import RNFS from 'react-native-fs';
import ProvenReactNative, {
    provenEventsFactory,
} from '@holdr/react-native';
import {
    Agent,
    IndyPoolConfig,
    type MediationConfig,
    type WalletConfig
} from '@holdr/core';

const walletConfig: WalletConfig = {
    uri: `sqlite://${RNFS.DocumentDirectoryPath}/local.db`,
    keyMethod: 'raw',
    passkey: 'CwNJroKHTSSj3XvE7ZAnuKiTn2C4QkFvxEqfm5rzhNrb',
    id: 'ReactNativeTest',
    profile: 'test',
};

const mediationConfig: MediationConfig = {
    mediatorInvitationUrl:
    'url invite to the mediator you want to use',
    baseMediatorReconnectionIntervalMS: 50,
    maximumMediatorReconnectionIntervalMS: 10000,
};

const poolConfig: IndyVDRPoolConfig = await IndyPoolConfig.fromURL(
    ProvenReactNative,
    'https://raw.githubusercontent.com/Indicio-tech/indicio-network/main/genesis_files/pool_transactions_demonet_genesis',
    false,
    'indicio-demo-net',
);

import ProvenReactNative, {
    provenEventsFactory,
} from '@holdr/react-native';

const agent = new Agent(
    ProvenReactNative,
    provenEventsFactory,
    licenseString,
    walletConfig,
    mediationConfig,
    [poolConfig],
    'RN',
    10,
    true,
    true,
    true,
    console.info // (message: string)->Void Callback to use for logging, defaults to console.log
);

await agent.start();

val didExchangeEvents? = agent.events.getEventBus(DidExchangeEvents::class)
// or
val didExchangeEvents = agent.events.getDidExchangeEvents()?: throw Error("Events not initialized by agent")

  // Example of what NOT to do
  val didExchangeEvents = agent.events.getDidExchangeEvents()?: throw Error("Events not initialized by agent")

  didExchangeEvents.events.onEach{
      // Causes deadlock because request connection will not return until the response message is processed
      // This can be avoided by calling this function in a separate thread
      agent.didExchange.requestConnection(it.didExchangeRecord.id, it.outOfBandRecord.id)
  }.collect()

  // Auto accept should be used instead of trying to do this. This is an intentionally BAD example

val didExchangeEvents = agent.events.getDidExchangeEvents()?: throw Error("Events not initialized by agent")
// Waits for the first didExchangeStateChangedEvent to be emitted that is in the completed state
didExchangeEvents.events.first{
  it.didExchangeRecord.state == DidExchangeState.Completed
}
// Additional attributes (such as ID) on the record can be used to wait for a specific record to reach a certain state

// Turns the didExchangeEvents into a swift asyncSequence
let credentialEvents = asyncSequence(for: agent.events.getCredentialEvents()!.events)

void (^removeListener)(ProvenmobileKotlinCancellationException * _Nullable) = 
  [agent.events onDidExchangeStateChangedCallback:^(
    ProvenmobileDidExchangeStateChangedEvent *_Nonnull event
  ) {
    // Handle DidExchangeStateChangedEvent here
  }

// Remove listener when no longer needed
removeListener(nil);

let removeListener = agent.events.onDidExchangeStateChanged { event in
  // Handle DidExchangeStateChangedEvent here
}
// Remove listener when no longer needed
removeListener(nil)

// Registers a handler that is called on all Did Exchange events
const didExchangeRemove = agent.events.registerDidExchangeHandler(
    event => {
      if (event.didExchangeRecord.state === DidExchangeState.COMPLETED) {
        console.log(
          'didExchange completed',
          event.didExchangeRecord.theirLabel,
        )
      }
    })

didExchangeRemove()

  // The url commonly comes from the result of scanning a QR code.
    val invitation = OutOfBandInvitationMessage.fromUrl(url)
    // Or if you have the message in json already
    val invitation = OutOfBandInvitationMessage.fromJsonString(str)

  // parses the URL to a json string
    const invitation: string = agent.outOfBand.parseInvitation(invitationUrl)

  // Completed connection status may or may not be done after this call
    val records = agent.outOfBand.receiveInvitation(invitation)

    //Waits for the record to be in the completed state
    agent.events.getDidExchangeEvents?.events?.first{ event ->
        if(records.didExchangeRecord.id != event.didExchangeRecord.id){
            event.didExchangeRecord.state == DidExchangeState.Completed
        }
    }

// Takes the json formatted string for the invitation
    const records = await agent.outOfBand.receiveInvitation(invitation)

    const removeListener = agent?.events.registerDidExchangeHandler((event) => {
              if(event.didExchangeRecord.id === records.didExchangeRecord.id && event.didExchangeRecord.isReady){
                console.log("Connection complete")
                removeListener()
              }
    })

// returns references to records needed to complete connection
val records = agent.outOfBand.receiveInvitation(invitation, autoAcceptConnection = false)

// Connection guaranteed to be completed after this call
val exchangeRecord = agent.didExchange.requestConnection(records.didExchangeRecord!!.id, records.outOfBandRecord.id)

const record = await agent.outOfBand.receiveInvitation(invitation, false)

const exchangeRecord = await agent.didExchange.requestConnection(records.didExchangeRecord!!.id, records.outOfBandRecord.id)

// This is a suspend function in Kotlin
val contacts: List<DidExchangeRecord> = agent.didExchange.getAll()

const contacts = await agent.didExchange.getAll()

  val contacts = agent.didExchange.getAll()
  // Deleting the first contact in the list
  agent.didExchange.deleteById(contacts[0].id)

const contacts = await agent.didExchange.getAll()

await agent.didExchange.deleteById(contacts[0].id)

  val credEvents = agent.events.getCredentialEvents()!! // Assuming agent initialized normally

    val offers = credEvents.events.filter {
        it.credentialExchangeRecord.state == CredentialState.OfferReceived
    }

    offers.onEach{
        // present to user
        if(userAccept)
            agent.credentials.acceptOffer(it.credentialExchangeRecord.id)
    }.collect()

  agent.events.registerCredentialHandler((event) => {
        if(event.credentialExchangeRecord.state === CredentialState.OfferReceived)
            // Present to user somehow
            if(userAccept)
                await agent.credentials.acceptOffer(event.credentialExchangeRecord.id)
    })

val receivedCredentials = credEvents.events.filter{
        it.credentialExchangeRecord.state == CredentialState.CredentialReceived
    }

    receivedCredentials.onEach{
        val attributes = it.credentialExchangeRecord.attributes       

        // User reviews the attributes of the credential
        if(userAccept)
            agent.credentials.acceptCredential(it.credentialExchangeRecord.id)
        else
            agent.credentials.rejectCredential(it.credentialExchangeRecord.id)
    }.collect()

  agent.events.registerCredentialHandler((event) => {
        const attributes = event.credentialExchangeRecord.attributes
        // Have user review credential
        if(userAccept)
            await agent.credentials.acceptCredential(event.credentialExchangeRecord.id)
        else
            await agent.credentials.rejectCredential(event.credentialExchangeRecord.id)
    })

  val record = agent.credentials.findByRecordId("Some id")

  const record = await agent.credential.findByRecordId("Some id")

  //Gets the first proof event received, blocks whatever thread it is ran on.
    val proofEvent = agent.events.getProofEvents().first()

    try {
        agent.proofs.autoAcceptProof(proofEvent.proofRecord.id, proofEvent.didExchangeId)
    } catch (e: Throwable) {
        println("An error occurred auto-accepting proof, message: ${e.message}")
    }

const removeProofHandler = agent.events.registerProofHandler(
        (event) => {
            try {
                if (event.proofRecord.state === ProofState.REQUEST_RECEIVED) {
                    await agent.proofs.autoAcceptProof(
                    event.proofRecord.id,
                    event.exchangeId);
                }
            } catch (error) {
                console.log(`An error ocurred auto-accepting proof, message ${error.message}`)
            }
        }
    )

  val proofEvent = agent.events.getProofEvents().first()

    // Returns a list of pairs containing first the proof and then the credential(s) selected
    val proofAttributes: SelectedCredentialsForProof = agent.proofs.autoSelectCredentialsForProof(
        proofEvent.proofRecord.id,
        proofEvent.didExchangeId,
        nonRevoked = false
    ) // nonRevoked indicates if you care if the credentials selected are revoked or not

    // Or

    // Returns a similar object but can potentially contain multiple credentials that need to be selected from
    val proofAttributes: SelectedCredentials = agent.proofs.getCredentialsForProofRequest(
        proofEvent.proofRecord.id,
        proofEvent.didExchangeId,
        nonRevoked = false
    )

  const removeProofHandler = agent.events.registerProofHandler(async (event) => {
        const proofAttributes = await agent.proofs.autoSelectCredentialsForProof(
            event.proofRecord.id,
            event.didExchangeId,
            false
        )

        // Or

        const proofAttributes = await agent.proofs.getCredentialsForProofRequest(
            event.proofRecord.id,
            event.didExchangeId,
            false
        )
    })

  val proofData = agent.proofs.autoSelectCredentialsForProof(
        proofEvent.proofRecord.id,
        proofEvent.didExchangeId,
        nonRevoked = false
    )

    // Check if there are any required self attested attributes
    val selfAttested = proofData.getRequiredSelfAttested()
    if(selftAttested.size != 0){
        selfAttested.forEach{ referent ->
            referent.selfAttestedValue = "Data from somewhere else"
        }
    }

    // This code provides a self attested value for all values that can be self attested but not all values have to be.

    // Supply the originally returned object that has been modified in place
    agent.proofs.acceptProofs(proofData)

  await const proofData = agent.proofs.autoSelectCredentialsForProof(
        event.proofRecord.id,
        event.didExchangeId,
        false
    )

    const selfAttested = proofData.getRequiredSelfAttested()

    if(selfAttested.size != 0) {
        selfAttested.forEach((referent) => {
            referent.selfAttestedValue = "Data from somewhere else"
        })
    }

    await agent.proofs.acceptProofs(proofData)

  val proofData = agent.proofs.getCredentialsForProofRequest(
        proofEvent.proofRecord.id,
        proofEvent.didExchangeId,
        nonRevoked = false
    )

    // Goes through all attributes and picks the first credential that matches
    proofData.attributes.forEach{ attribute =>
        attribute.selectCredential(0)
    }

    proofData.predicates.forEach{ predicate =>
        predicate.selectCredential(0)
    }

    agent.proofs.acceptProofs(proofData)

  await const proofData = agent.proofs.getCredentialsForProofRequest(
        proofEvent.proofRecord.id,
        proofEvent.didExchangeId,
        nonRevoked = false
    )

    proofData.attributes.forEach((attribute) => {
        attribute.selectCredential(0)
    })

    proofData.predicates.forEach((predicate) => {
        predicate.selectCredential(0)
    })

    await agent.proofs.acceptProofs(proofData)