plugins {
    id 'com.android.application'
    id 'kotlin-android'
    id 'kotlin-kapt'
}

dependencies {
    def appsearch_version = "1.0.0-alpha02"
    implementation "androidx.appsearch:appsearch:$appsearch_version"
    // Use kapt instead of annotationProcessor if writing Kotlin classes
    kapt "androidx.appsearch:appsearch-compiler:$appsearch_version"
    implementation "androidx.appsearch:appsearch-local-storage:$appsearch_version"
}

implementation 'com.google.guava:guava:27.0.1-android'

@Document
data class MovieDocument(
    // Required field for a document class. All documents MUST have a namespace.
    @Document.Namespace
    val namespace: String,
    // Required field for a document class. All documents MUST have an Id.
    @Document.Id
    val id: String,
    // Optional field for a document class, used to set the score of the
    // document. If this is not included in a document class, the score is set
    // to a default of 0.
    @Document.Score
    val score: Int,
    // Optional field for a document class, used to index a movie's text for this
    // document class.
    @Document.StringProperty(indexingType = AppSearchSchema.StringPropertyConfig.INDEXING_TYPE_PREFIXES)
    val title: String,
    @Document.StringProperty(indexingType = AppSearchSchema.StringPropertyConfig.INDEXING_TYPE_PREFIXES)
    val text: String,
    @Document.StringProperty
    val poster: String?
)

val sessionFuture: ListenableFuture<AppSearchSession> = LocalStorage.createSearchSession(
       LocalStorage.SearchContext.Builder(activity?.applicationContext!!, "movies_demo_db")
           .build()
   )

fun setSchema(documentClasses: Collection<Class<*>>) {
    val setSchemaRequest =
        SetSchemaRequest.Builder().addDocumentClasses(documentClasses)
            .build()
   // Created ListenableFuture
    val setSchemaFuture = Futures.transformAsync(
        sessionFuture,
        { session ->
            session?.setSchema(setSchemaRequest)
        }, threadPoolExecutor
    )
    Futures.addCallback(
        setSchemaFuture,
        object : FutureCallback<SetSchemaResponse> {
            override fun onSuccess(result: SetSchemaResponse?) {
                Log.d(TAG, "SetSchemaResponse success. $result")
            }
            override fun onFailure(t: Throwable) {
                Log.d(TAG, "Failed to put documents. $t")
            }
        },
        threadPoolExecutor
    )
}

val putRequest = PutDocumentsRequest.Builder().addDocuments(documents).build()

val putFuture = Futures.transformAsync(
    sessionFuture,
    { session ->
        session?.put(putRequest)
    }, threadPoolExecutor
)

fun saveData(documents: List<Any>): Observable<Boolean> {
    val putRequest = PutDocumentsRequest.Builder().addDocuments(documents).build()
    val putFuture = Futures.transformAsync(
        sessionFuture,
        { session ->
            session?.put(putRequest)
        }, threadPoolExecutor
    )
    return Observable.create { emitter ->
        Futures.addCallback(
            putFuture,
            object : FutureCallback<AppSearchBatchResult<String, Void>?> {
                override fun onSuccess(result: AppSearchBatchResult<String, Void>?) {
                    // Gets map of successful results from Id to Void
                    val successfulResults = result?.successes
                    Log.d(TAG, "successfulResults" + result?.successes)
                    // Gets map of failed results from Id to AppSearchResult
                    val failedResults = result?.failures
                    Log.d(TAG, "failedResults" + result?.failures)
                    emitter.onNext(true)
                }
                override fun onFailure(t: Throwable) {
                    Log.e(TAG, "Failed to put documents. $t")
                    emitter.onError(t)
                }
            },
            threadPoolExecutor
        )
    }
}

val searchSpec = SearchSpec.Builder()
    .addFilterNamespaces(nameSpace)
    .build()

fun search(term: String, nameSpace: String? = ""): Observable<SearchResults> {
    Log.d(TAG, "search: $term")
    val searchSpec = SearchSpec.Builder()
        .addFilterNamespaces(nameSpace)
        .build();
    val searchFuture: ListenableFuture<SearchResults> = Futures.transform(
        sessionFuture,
        { session ->
            session?.search(term, searchSpec)
        },
        threadPoolExecutor
    )
    return Observable.create { emitter ->
        Futures.addCallback(
            searchFuture,
            object : FutureCallback<SearchResults> {
                override fun onSuccess(searchResults: SearchResults?) {
                    searchResults?.let { emitter.onNext(searchResults) }
                }
                override fun onFailure(t: Throwable) {
                    emitter.onError(t)
                }
            },
            threadPoolExecutor
        )
    }
}

public interface SearchResults extends Closeable {
    /**
     * Retrieves the next page of {@link SearchResult} objects.
     *
     * <p>The page size is configured by {@link SearchSpec.Builder#setResultCountPerPage}.
     *
     * <p>Continue calling this method to access results until it returns an empty list,
     * signifying there are no more results.
     *
     * @return a {@link ListenableFuture} which resolves to a list of {@link SearchResult}
     * objects.
     */
    @NonNull
    ListenableFuture<List<SearchResult>> getNextPage();
    @Override
    void close();
}

fun iterateSearchResults(
    searchResults: SearchResults?
): Observable<List<GenericDocument>> {
    val getDocumentsFuture: ListenableFuture<List<GenericDocument>> = Futures.transform(
        searchResults?.nextPage,
        { page: List<SearchResult>? ->
            // Gets GenericDocument from SearchResult.
            val genericDocument: List<GenericDocument>? =
                page?.map { it.genericDocument }?.toList()
            genericDocument
        },
        threadPoolExecutor
    )
    return Observable.create { emitter ->
        Futures.addCallback(
            getDocumentsFuture,
            object : FutureCallback<List<GenericDocument>> {
                override fun onSuccess(result: List<GenericDocument>?) {
                    result?.let {
                        Log.d(TAG, "onSuccess $result")
                        emitter.onNext(result)
                    }
                }
                override fun onFailure(t: Throwable) {
                    Log.d(TAG, "onFailure $t")
                    emitter.onError(t)
                }
            },
            threadPoolExecutor
        )
    }
}

compositeDisposable.add(
    binding.searchToolbar.onTextChangedObservable.debounce(1, TimeUnit.SECONDS)
        .filter { it.length > 4 }
        .flatMap { repository.search(it) }
        .flatMap { repository.iterateSearchResults(it) }
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe({ result ->
            val allMovies: MutableList<MovieDocument> = mutableListOf()
            val allPerson: MutableList<PersonDocument> = mutableListOf()
            result?.forEach { genericDocument ->
                val schemaType = genericDocument.schemaType
                try {
                    if (schemaType == "MovieDocument") {
                        // Converts GenericDocument object to MovieDocument object.
                        allMovies.add(genericDocument.toDocumentClass(MovieDocument::class.java))
                    } else if (schemaType == "PersonDocument") {
                        allPerson.add(genericDocument.toDocumentClass(PersonDocument::class.java))
                    }
                } catch (e: AppSearchException) {
                    Log.d(TAG, "Failed to convert GenericDocument $e")
                }
            }
            adapter.clear()
            val movies =
                allMovies.map { MoviePreviewItem(MovieMapper.fromMovieDocument(it)) {} }
                    .toList()
            if (movies.isNotEmpty()) {
                val movieItem = MainCardContainer("Movies", movies)
                binding.eventsRecyclerView.adapter = adapter.apply { add(movieItem) }
            }
            val personItems =
                allPerson.map { PersonItem(PersonMapper.fromPersonDocument(it)) {} }
                    .toList()
            if (personItems.isNotEmpty()) {
                val personResultItem = MainCardContainer("Actors", personItems)
                binding.eventsRecyclerView.adapter = adapter.apply { add(personResultItem) }
            }
        },
            {
                Log.d(TAG, "Error: $it")
            })
)