/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */

package org.apache.usergrid.corepersistence.service;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.apache.usergrid.corepersistence.pipeline.builder.EntityBuilder;
import org.apache.usergrid.corepersistence.pipeline.builder.IdBuilder;
import org.apache.usergrid.corepersistence.pipeline.builder.PipelineBuilderFactory;
import org.apache.usergrid.corepersistence.pipeline.read.ResultsPage;
import org.apache.usergrid.corepersistence.rx.impl.AllEntityIdsObservable;
import org.apache.usergrid.corepersistence.util.CpNamingUtils;
import org.apache.usergrid.persistence.ConnectionRef;
import org.apache.usergrid.persistence.collection.serialization.impl.migration.EntityIdScope;
import org.apache.usergrid.persistence.core.scope.ApplicationScope;
import org.apache.usergrid.persistence.graph.GraphManager;
import org.apache.usergrid.persistence.graph.GraphManagerFactory;
import org.apache.usergrid.persistence.graph.SearchByEdge;
import org.apache.usergrid.persistence.graph.SearchByEdgeType;
import org.apache.usergrid.persistence.graph.impl.SimpleSearchByEdge;
import org.apache.usergrid.persistence.graph.impl.SimpleSearchByEdgeType;
import org.apache.usergrid.persistence.graph.impl.SimpleSearchEdgeType;
import org.apache.usergrid.persistence.model.entity.Entity;
import org.apache.usergrid.persistence.model.entity.Id;

import com.google.common.base.Optional;
import com.google.inject.Inject;
import com.google.inject.Singleton;

import rx.Observable;


@Singleton
public class ConnectionServiceImpl implements ConnectionService {


    private static final Logger logger = LoggerFactory.getLogger( ConnectionServiceImpl.class );

    private final PipelineBuilderFactory pipelineBuilderFactory;
    private final AllEntityIdsObservable allEntityIdsObservable;
    private final GraphManagerFactory graphManagerFactory;


    @Inject
    public ConnectionServiceImpl( final PipelineBuilderFactory pipelineBuilderFactory,
                                  final AllEntityIdsObservable allEntityIdsObservable,
                                  final GraphManagerFactory graphManagerFactory ) {
        this.pipelineBuilderFactory = pipelineBuilderFactory;
        this.allEntityIdsObservable = allEntityIdsObservable;
        this.graphManagerFactory = graphManagerFactory;
    }


    @Override
    public Observable<ResultsPage<Entity>> searchConnection( final ConnectionSearch search ) {
        //set startid -- graph | es query filter -- load entities filter (verifies exists) --> results page collector
        // -> 1.0 results

        //  startid -- graph edge load -- entity load (verify) from ids -> results page collector
        // startid -- eq query candiddate -- entity load (verify) from canddiates -> results page collector

        //startid -- graph edge load -- entity id verify --> filter to connection ref --> connection ref collector
        //startid -- eq query candiddate -- candidate id verify --> filter to connection ref --> connection ref
        // collector


        final Optional<String> query = search.getQuery();

        final IdBuilder pipelineBuilder =
            pipelineBuilderFactory.create( search.getApplicationScope() ).withCursor( search.getCursor() )
                                  .withLimit( search.getLimit() ).fromId( search.getSourceNodeId() );


        //we want to load all entities

        final EntityBuilder results;


        if ( !query.isPresent() ) {
            if(search.getIsConnecting()){
                results = pipelineBuilder.traverseReverseConnection(search.getConnectionName(), search.getEntityType()).loadEntities();
            }
            else {
                results =
                    pipelineBuilder.traverseConnection(search.getConnectionName(), search.getEntityType()).loadEntities();
            }
        }

        else {

            results =
                pipelineBuilder.searchConnection( search.getConnectionName(), query.get(), search.getEntityType(), search.getAnalyzeOnly() )
                               .loadEntities();
        }


        return results.build();
    }


    @Override
    public Observable<ResultsPage<ConnectionRef>> searchConnectionAsRefs( final ConnectionSearch search ) {

        final Optional<String> query = search.getQuery();

        final Id sourceNodeId = search.getSourceNodeId();

        final IdBuilder pipelineBuilder =
            pipelineBuilderFactory.create( search.getApplicationScope() ).withCursor( search.getCursor() )
                                  .withLimit( search.getLimit() ).fromId( sourceNodeId );


        final IdBuilder traversedIds;
        final String connectionName = search.getConnectionName();

        if ( !query.isPresent() ) {
            traversedIds = pipelineBuilder.traverseConnection( connectionName, search.getEntityType() );
        }
        else {
            traversedIds =
                pipelineBuilder.searchConnection( connectionName, query.get(), search.getEntityType(), search.getAnalyzeOnly() ).loadIds();
        }

        //create connection refs

        final Observable<ResultsPage<ConnectionRef>> results =
            traversedIds.loadConnectionRefs( sourceNodeId, connectionName ).build();

        return results;
    }


    @Override
    public Observable<ConnectionScope> deDupeConnections(
        final Observable<ApplicationScope> applicationScopeObservable ) {


        final Observable<EntityIdScope> entityIds = allEntityIdsObservable.getEntities( applicationScopeObservable );
        //now we have an observable of entityIds.  Walk each connection type

        //get all edge types for connections
        return entityIds.flatMap( entityIdScope -> {

            final ApplicationScope applicationScope = entityIdScope.getApplicationScope();
            final Id entityId = entityIdScope.getId();

            final GraphManager gm = graphManagerFactory.createEdgeManager( applicationScope );

            if (logger.isDebugEnabled()) {
                logger.debug("Checking connections of id {} in application {}", entityId, applicationScope);
            }

            return gm.getEdgeTypesFromSource(
                new SimpleSearchEdgeType( entityId, CpNamingUtils.EDGE_CONN_PREFIX, Optional.absent() ) )

                //now load all edges from this node of this type
                .flatMap( edgeType -> {

                    if (logger.isDebugEnabled()) {
                        logger.debug("Found edge of types of {}, searching for edges", edgeType);
                    }

                    final SearchByEdgeType searchByEdge =
                        new SimpleSearchByEdgeType( entityId, edgeType, Long.MAX_VALUE,
                            SearchByEdgeType.Order.DESCENDING, Optional.absent() );

                    //load edges from the source the with type specified
                    return gm.loadEdgesFromSource( searchByEdge );
                } )

                    //now that we have a stream of edges, stream all versions
                .flatMap( edge -> {

                    if (logger.isDebugEnabled()) {
                        logger.debug("Found edge {}, searching for multiple versions of edge", edge);
                    }

                    //keep only the most recent
                    final SearchByEdge searchByEdge =
                        new SimpleSearchByEdge( edge.getSourceNode(), edge.getType(), edge.getTargetNode(), Long.MAX_VALUE,
                            SearchByEdgeType.Order.DESCENDING, Optional.absent() );
                    return gm.loadEdgeVersions( searchByEdge )
                        //skip the first version since it's the one we want to retain
                        .skip( 1 )
                            //mark for deletion
                        .flatMap( edgeToDelete -> {

                            if (logger.isDebugEnabled()) {
                                logger.debug("Deleting edge {}", edgeToDelete);
                            }

                            //mark the edge and ignore the cleanup result
                            return gm.markEdge( edgeToDelete );
                        } )
                            //mark all versions, then on the last, delete them from cass
                        .flatMap( lastMarkedEdge -> gm.deleteEdge( lastMarkedEdge ) );


                    // validate there is only 1 version of it, delete anything > than the min

                } ).map( deletedEdge -> new ConnectionScope( applicationScope, deletedEdge ) );
        } );
    }
}