package org.testtools.jsondiff.matcher;

import org.testtools.jsondiff.CompareContext;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

/**
 * Custom matcher for comparing date strings in YYYY-MM-DD format
 */
public class DateStringMatcher<T> implements ValueMatcher<T> {
    private DateTimeFormatter formatter;
    
    public DateStringMatcher() {
        this.formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    }
    
    @Override
    public boolean equal(T actual, T expected) {
        try {
            String actualStr = actual.toString();
            String expectedStr = expected.toString();
            
            LocalDate actualDate = LocalDate.parse(actualStr, formatter);
            LocalDate expectedDate = LocalDate.parse(expectedStr, formatter);
            
            return actualDate.equals(expectedDate);
        } catch (Exception e) {
            // If parsing fails, fall back to string comparison
            return actual.equals(expected);
        }
    }
    
    @Override
    public void matcherInit(String param, CompareContext compareContext) {
        // Parse custom date format from parameter if provided
        if (param != null && !param.trim().isEmpty()) {
            try {
                this.formatter = DateTimeFormatter.ofPattern(param.trim());
            } catch (Exception e) {
                // Keep default format if parameter is invalid
            }
        }
    }
}

package org.testtools.jsondiff.matcher;

import org.testtools.jsondiff.CompareContext;
import org.testtools.jsondiff.JSONCompareDetailResult;
import org.testtools.jsondiff.comparator.JSONComparator;
import org.testtools.jsondiff.comparator.JSONCompareUtil;
import java.math.BigDecimal;
import java.util.Objects;

/**
 * Custom matcher for comparing numeric ranges with percentage tolerance
 */
public class RangePercentageMatcher<T> implements CustomValueMatcher<T> {
    private double percentageTolerance;
    
    public RangePercentageMatcher() {
        this.percentageTolerance = 5.0; // Default 5% tolerance
    }
    
    @Override
    public boolean equal(T actual, T expected) {
        // Basic implementation for simple comparison
        return equal(null, actual, expected, null, null);
    }
    
    @Override
    public boolean equal(String prefix, T actual, T expected, 
                        JSONCompareDetailResult result, JSONComparator comparator) 
                        throws ValueMatcherException {
        try {
            BigDecimal actualNum = new BigDecimal(actual.toString());
            BigDecimal expectedNum = new BigDecimal(expected.toString());
            
            // Calculate percentage difference
            BigDecimal diff = actualNum.subtract(expectedNum).abs();
            BigDecimal percentageDiff = diff.divide(expectedNum, 4, BigDecimal.ROUND_HALF_UP)
                                          .multiply(BigDecimal.valueOf(100));
            
            boolean isWithinTolerance = percentageDiff.compareTo(BigDecimal.valueOf(percentageTolerance)) <= 0;
            
            if (!isWithinTolerance && result != null) {
                // Add detailed failure information
                result.fail(prefix, 
                    String.format("Expected value within %.2f%% tolerance", percentageTolerance),
                    String.format("Actual: %s, Expected: %s, Difference: %.2f%%", 
                                 actual, expected, percentageDiff.doubleValue()));
            }
            
            return isWithinTolerance;
        } catch (NumberFormatException e) {
            // Fall back to exact comparison for non-numeric values
            return actual.equals(expected);
        }
    }
    
    @Override
    public void matcherInit(String param, CompareContext compareContext) {
        if (param != null && !param.trim().isEmpty()) {
            try {
                this.percentageTolerance = Double.parseDouble(
                    Objects.requireNonNull(JSONCompareUtil.getParamValue(param)));
            } catch (Exception e) {
                // Keep default tolerance if parameter is invalid
            }
        }
    }
}