Dépôt officiel du code source de l'ERP OpenConcerto

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2011-2019 OpenConcerto, by ILM Informatique. All rights reserved.

 *

 * The contents of this file are subject to the terms of the GNU General Public License Version 3

 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a

 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific

 * language governing permissions and limitations under the License.

 *

 * When distributing the software, include this License Header Notice in each file.

 */

 package org.openconcerto.sql.view.search;

import org.openconcerto.utils.FormatGroup;

import java.text.Format;

import java.text.Normalizer;

import java.text.Normalizer.Form;

import java.text.ParsePosition;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.regex.Pattern;

/**

 * Search a text in an object (first in toString() then using formats).

 *

 * @author Sylvain

 */

public class TextSearchSpec implements SearchSpec {

    public static enum Mode {

        CONTAINS, CONTAINS_STRICT, LESS_THAN, EQUALS, EQUALS_STRICT, GREATER_THAN

    }

    // cannot use Collator : it doesn't works for CONTAINS

    static private final Pattern thoroughPattern = Pattern.compile("(\\p{Punct}|\\p{InCombiningDiacriticalMarks})+");

    static private final Pattern multipleSpacesPattern = Pattern.compile("\\p{Space}+");

    private final Mode mode;

    private final String filterString, normalizedFilterString;

    private final Map<Class<?>, FormatGroup> formats;

    // parsing of filterString for each format

    private final Map<Format, Object> parsedFilter;

    private Double parsedFilterD;

    private boolean parsedFilterD_tried = false;

    public TextSearchSpec(String filterString) {

        this(filterString, Mode.CONTAINS);

    }

    public TextSearchSpec(String filterString, final Mode mode) {

        this.mode = mode;

        this.filterString = filterString;

        this.normalizedFilterString = normalize(filterString);

        this.formats = new HashMap<>();

        this.parsedFilter = new HashMap<>();

    }

    private String normalize(String s) {

        if (this.mode == Mode.CONTAINS_STRICT || this.mode == Mode.EQUALS_STRICT) {

            return s.trim();

        } else {

            final String sansAccents = thoroughPattern.matcher(Normalizer.normalize(s.trim(), Form.NFD)).replaceAll("");

            return multipleSpacesPattern.matcher(sansAccents).replaceAll(" ").toLowerCase();

        }

    }

    private final Object getParsed(final Format fmt) {

        Object res;

        if (this.parsedFilter.containsKey(fmt)) {

            res = this.parsedFilter.get(fmt);

        } else {

            final ParsePosition pp = new ParsePosition(0);

            res = fmt.parseObject(this.filterString, pp);

            // don't allow "25/12/05foobar" or worse "25/12/05 13:00" (parsing to "25/12/05 00:00")

            if (pp.getErrorIndex() >= 0 || pp.getIndex() < this.filterString.length())

                res = null;

            else

                assert res != null : "Cannot tell apart parsing failed from parsed to null";

            this.parsedFilter.put(fmt, res);

        }

        return res;

    }

    private final String format(final Format fmt, final Object cell) {

        try {

            return fmt.format(cell);

        } catch (final Exception e) {

            throw new IllegalStateException("Couldn't format " + cell + '(' + getClass(cell) + ") with " + fmt, e);

        }

    }

    static private String getClass(Object cell) {

        return cell == null ? "<null>" : cell.getClass().getName();

    }

    private final Double getDouble() {

        if (!this.parsedFilterD_tried) {

            try {

                this.parsedFilterD = Double.valueOf(this.filterString);

            } catch (final NumberFormatException e) {

                this.parsedFilterD = null;

            }

            this.parsedFilterD_tried = true;

        }

        return this.parsedFilterD;

    }

    private boolean matchWithFormats(Object cell) {

        if (cell == null)

            return false;

        // return now since only the toString() of strings can be sorted (it makes no sense to sort

        // 12/25/2010)

        if (cell.getClass() == String.class)

            return test(cell.toString());

        final boolean containsOrEquals = isContainsOrEquals();

        final boolean isContains = isContains();

        // first an inexpensive comparison

        if (containsOrEquals && containsOrEquals(cell.toString()))

            return true;

        // then try to format the cell

        final FormatGroup fg = getFormat(cell);

        if (fg != null) {

            final List<? extends Format> fmts = fg.getFormats();

            final int stop = fmts.size();

            for (int i = 0; i < stop; i++) {

                final Format fmt = fmts.get(i);

                // e.g. test if "2006" is contained in "25 déc. 2010"

                // for the equals mode we can either format the cell value and compare it to the

                // user typed string, or we can parse the user typed string and compare it to the

                // cell value.

                // The problem with the first approach is that some formats lose information (e.g. a

                // date format for a timestamp loses the time part : 25/12/2010 13:00 would be

                // formatted to 25/12/2010 thus "= 25/12/2010" would select all times of that day,

                // which is better achieved with contains)

                // PS: the date format is useful for parsing since "> 25/12/2010" means

                // "> 25/12/2010 00:00" which is understandable and concise.

                if (isContains && containsOrEquals(format(fmt, cell)))

                    return true;

                // e.g. test if "01/01/2006" is before "25 déc. 2010"

                else if (!isContains && test(getParsed(fmt), cell))

                    return true;

            }

        } else if (!isContains && cell instanceof Number) {

            final Number n = (Number) cell;

            if (test(this.getDouble(), n.doubleValue()))

                return true;

        }

        return false;

    }

    private boolean test(final String searched) {

        final String normalized = normalize(searched);

        if (isContains())

            return normalized.indexOf(this.normalizedFilterString) >= 0;

        else if (this.mode == Mode.EQUALS || this.mode == Mode.EQUALS_STRICT)

            return normalized.equals(this.normalizedFilterString);

        else if (this.mode == Mode.LESS_THAN)

            return normalized.compareTo(this.normalizedFilterString) <= 0;

        else if (this.mode == Mode.GREATER_THAN)

            return normalized.compareTo(this.normalizedFilterString) >= 0;

        else

            throw new IllegalArgumentException("unknown mode " + this.mode);

    }

    private boolean isContainsOrEquals() {

        // only real Strings can be sorted (it makes no sense to sort 12/25/2010)

        return this.mode != Mode.LESS_THAN && this.mode != Mode.GREATER_THAN;

    }

    private boolean isContains() {

        return this.mode == Mode.CONTAINS || this.mode == Mode.CONTAINS_STRICT;

    }

    private boolean containsOrEquals(final String searched) {

        // don't normalize otherwise 2005-06-20 matches 2006 :

        // searched is first formatted to 20/06/2005 then normalized to 20062005

        if (isContains()) {

            return searched.indexOf(this.filterString) >= 0;

        } else {

            assert this.mode == Mode.EQUALS || this.mode == Mode.EQUALS_STRICT : "Only call contains() if isContainsOrEquals()";

            return searched.equals(this.filterString);

        }

    }

    @SuppressWarnings("unchecked")

    private boolean test(Object search, final Object cell) {

        assert !(this.mode == Mode.CONTAINS || this.mode == Mode.CONTAINS_STRICT) : "Only call test() if not isContains()";

        if (search == null)

            return false;

        if (cell instanceof Comparable) {

            final Comparable c = (Comparable<?>) cell;

            if (this.mode == Mode.EQUALS || this.mode == Mode.EQUALS_STRICT) {

                // allow to compare Timestamp & Date

                return c.compareTo(search) == 0;

            } else if (this.mode == Mode.LESS_THAN) {

                return c.compareTo(search) <= 0;

            } else {

                assert this.mode == Mode.GREATER_THAN;

                return c.compareTo(search) >= 0;

            }

        } else {

            if (this.mode == Mode.EQUALS || this.mode == Mode.EQUALS_STRICT)

                return cell.equals(search);

            else

                return false;

        }

    }

    private FormatGroup getFormat(Object cell) {

        final Class<?> clazz = cell.getClass();

        if (!this.formats.containsKey(clazz)) {

            // cache the findings (eg sql.Date can be formatted like util.Date)

            this.formats.put(clazz, findFormat(clazz));

        }

        return this.formats.get(clazz);

    }

    // find if there's a format for cell

    // 1st tries its class, then goes up the hierarchy

    private FormatGroup findFormat(final Class<?> clazz) {

        Class<?> c = clazz;

        FormatGroup res = null;

        while (res == null && c != Object.class) {

            res = this.formats.get(c);

            c = c.getSuperclass();

        }

        return res;

    }

    @Override

    public boolean match(Object line) {

        return this.isEmpty() || matchWithFormats(line);

    }

    @Override

    public String toString() {

        return this.getClass().getSimpleName() + ":" + this.filterString;

    }

    @Override

    public boolean isEmpty() {

        return this.filterString == null || this.filterString.length() == 0;

    }

    public void setFormats(Map<Class<?>, FormatGroup> formats) {

        this.formats.clear();

        this.formats.putAll(formats);

    }

}