/*
 * 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.tika.eval.tools;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.lucene.index.*;
import org.apache.lucene.index.MultiDocValues.MultiSortedDocValues;
import org.apache.lucene.util.Bits;
import org.apache.lucene.util.Version;

/**
 * <b>COPIED VERBATIM FROM LUCENE</b>
 * This class forces a composite reader (eg a {@link
 * MultiReader} or {@link DirectoryReader}) to emulate a
 * {@link LeafReader}.  This requires implementing the postings
 * APIs on-the-fly, using the static methods in {@link
 * MultiTerms}, {@link MultiDocValues}, by stepping through
 * the sub-readers to merge fields/terms, appending docs, etc.
 *
 * <p><b>NOTE</b>: this class almost always results in a
 * performance hit.  If this is important to your use case,
 * you'll get better performance by gathering the sub readers using
 * {@link IndexReader#getContext()} to get the
 * leaves and then operate per-LeafReader,
 * instead of using this class.
 */

public final class SlowCompositeReaderWrapper extends LeafReader {

    private final CompositeReader in;
    private final LeafMetaData metaData;

    // Cached copy of FieldInfos to prevent it from being re-created on each
    // getFieldInfos call.  Most (if not all) other LeafReader implementations
    // also have a cached FieldInfos instance so this is consistent. SOLR-12878
    private final FieldInfos fieldInfos;

    final Map<String,Terms> cachedTerms = new ConcurrentHashMap<>();

    // TODO: consider ConcurrentHashMap ?
    // TODO: this could really be a weak map somewhere else on the coreCacheKey,
    // but do we really need to optimize slow-wrapper any more?
    final Map<String,OrdinalMap> cachedOrdMaps = new HashMap<>();

    /** This method is sugar for getting an {@link LeafReader} from
     * an {@link IndexReader} of any kind. If the reader is already atomic,
     * it is returned unchanged, otherwise wrapped by this class.
     */
    public static LeafReader wrap(IndexReader reader) throws IOException {
        if (reader instanceof CompositeReader) {
            return new SlowCompositeReaderWrapper((CompositeReader) reader);
        } else {
            assert reader instanceof LeafReader;
            return (LeafReader) reader;
        }
    }

    SlowCompositeReaderWrapper(CompositeReader reader) throws IOException {
        in = reader;
        in.registerParentReader(this);
        if (reader.leaves().isEmpty()) {
            metaData = new LeafMetaData(Version.LATEST.major, Version.LATEST, null);
        } else {
            Version minVersion = Version.LATEST;
            for (LeafReaderContext leafReaderContext : reader.leaves()) {
                Version leafVersion = leafReaderContext.reader().getMetaData().getMinVersion();
                if (leafVersion == null) {
                    minVersion = null;
                    break;
                } else if (minVersion.onOrAfter(leafVersion)) {
                    minVersion = leafVersion;
                }
            }
            metaData = new LeafMetaData(reader.leaves().get(0).reader().getMetaData().getCreatedVersionMajor(), minVersion, null);
        }
        fieldInfos = FieldInfos.getMergedFieldInfos(in);
    }

    @Override
    public String toString() {
        return "SlowCompositeReaderWrapper(" + in + ")";
    }

    @Override
    public CacheHelper getReaderCacheHelper() {
        return in.getReaderCacheHelper();
    }

    @Override
    public CacheHelper getCoreCacheHelper() {
        // TODO: this is trappy as the expectation is that core keys live for a long
        // time, but here we need to bound it to the lifetime of the wrapped
        // composite reader? Unfortunately some features seem to rely on this...
        return in.getReaderCacheHelper();
    }

    @Override
    public Terms terms(String field) throws IOException {
        ensureOpen();
        try {
            return cachedTerms.computeIfAbsent(field, f -> {
                try {
                    return MultiTerms.getTerms(in, f);
                } catch (IOException e) { // yuck!  ...sigh... checked exceptions with built-in lambdas are a pain
                    throw new RuntimeException("unwrapMe", e);
                }
            });
        } catch (RuntimeException e) {
            if (e.getMessage().equals("unwrapMe") && e.getCause() instanceof IOException) {
                throw (IOException) e.getCause();
            }
            throw e;
        }
    }

    @Override
    public NumericDocValues getNumericDocValues(String field) throws IOException {
        ensureOpen();
        return MultiDocValues.getNumericValues(in, field); // TODO cache?
    }

    @Override
    public BinaryDocValues getBinaryDocValues(String field) throws IOException {
        ensureOpen();
        return MultiDocValues.getBinaryValues(in, field); // TODO cache?
    }

    @Override
    public SortedNumericDocValues getSortedNumericDocValues(String field) throws IOException {
        ensureOpen();
        return MultiDocValues.getSortedNumericValues(in, field); // TODO cache?
    }

    @Override
    public SortedDocValues getSortedDocValues(String field) throws IOException {
        ensureOpen();
        OrdinalMap map = null;
        synchronized (cachedOrdMaps) {
            map = cachedOrdMaps.get(field);
            if (map == null) {
                // uncached, or not a multi dv
                SortedDocValues dv = MultiDocValues.getSortedValues(in, field);
                if (dv instanceof MultiSortedDocValues) {
                    map = ((MultiSortedDocValues)dv).mapping;
                    IndexReader.CacheHelper cacheHelper = getReaderCacheHelper();
                    if (cacheHelper != null && map.owner == cacheHelper.getKey()) {
                        cachedOrdMaps.put(field, map);
                    }
                }
                return dv;
            }
        }
        int size = in.leaves().size();
        final SortedDocValues[] values = new SortedDocValues[size];
        final int[] starts = new int[size+1];
        long totalCost = 0;
        for (int i = 0; i < size; i++) {
            LeafReaderContext context = in.leaves().get(i);
            final LeafReader reader = context.reader();
            final FieldInfo fieldInfo = reader.getFieldInfos().fieldInfo(field);
            if (fieldInfo != null && fieldInfo.getDocValuesType() != DocValuesType.SORTED) {
                return null;
            }
            SortedDocValues v = reader.getSortedDocValues(field);
            if (v == null) {
                v = DocValues.emptySorted();
            }
            totalCost += v.cost();
            values[i] = v;
            starts[i] = context.docBase;
        }
        starts[size] = maxDoc();
        return new MultiSortedDocValues(values, starts, map, totalCost);
    }

    @Override
    public SortedSetDocValues getSortedSetDocValues(String field) throws IOException {
        ensureOpen();
        OrdinalMap map = null;
        synchronized (cachedOrdMaps) {
            map = cachedOrdMaps.get(field);
            if (map == null) {
                // uncached, or not a multi dv
                SortedSetDocValues dv = MultiDocValues.getSortedSetValues(in, field);
                if (dv instanceof MultiDocValues.MultiSortedSetDocValues) {
                    map = ((MultiDocValues.MultiSortedSetDocValues)dv).mapping;
                    IndexReader.CacheHelper cacheHelper = getReaderCacheHelper();
                    if (cacheHelper != null && map.owner == cacheHelper.getKey()) {
                        cachedOrdMaps.put(field, map);
                    }
                }
                return dv;
            }
        }

        assert map != null;
        int size = in.leaves().size();
        final SortedSetDocValues[] values = new SortedSetDocValues[size];
        final int[] starts = new int[size+1];
        long cost = 0;
        for (int i = 0; i < size; i++) {
            LeafReaderContext context = in.leaves().get(i);
            final LeafReader reader = context.reader();
            final FieldInfo fieldInfo = reader.getFieldInfos().fieldInfo(field);
            if(fieldInfo != null && fieldInfo.getDocValuesType() != DocValuesType.SORTED_SET){
                return null;
            }
            SortedSetDocValues v = reader.getSortedSetDocValues(field);
            if (v == null) {
                v = DocValues.emptySortedSet();
            }
            values[i] = v;
            starts[i] = context.docBase;
            cost += v.cost();
        }
        starts[size] = maxDoc();
        return new MultiDocValues.MultiSortedSetDocValues(values, starts, map, cost);
    }

    @Override
    public NumericDocValues getNormValues(String field) throws IOException {
        ensureOpen();
        return MultiDocValues.getNormValues(in, field); // TODO cache?
    }

    @Override
    public Fields getTermVectors(int docID) throws IOException {
        ensureOpen();
        return in.getTermVectors(docID);
    }

    @Override
    public int numDocs() {
        // Don't call ensureOpen() here (it could affect performance)
        return in.numDocs();
    }

    @Override
    public int maxDoc() {
        // Don't call ensureOpen() here (it could affect performance)
        return in.maxDoc();
    }

    @Override
    public void document(int docID, StoredFieldVisitor visitor) throws IOException {
        ensureOpen();
        in.document(docID, visitor);
    }

    @Override
    public Bits getLiveDocs() {
        ensureOpen();
        return MultiBits.getLiveDocs(in); // TODO cache?
    }

    @Override
    public PointValues getPointValues(String field) {
        ensureOpen();
        return null; // because not supported.  Throw UOE?
    }

    @Override
    public FieldInfos getFieldInfos() {
        return fieldInfos;
    }

    @Override
    protected void doClose() throws IOException {
        // TODO: as this is a wrapper, should we really close the delegate?
        in.close();
    }

    @Override
    public void checkIntegrity() throws IOException {
        ensureOpen();
        for (LeafReaderContext ctx : in.leaves()) {
            ctx.reader().checkIntegrity();
        }
    }

    @Override
    public LeafMetaData getMetaData() {
        return metaData;
    }
}