Time Series Trend Detector (java, written by Claude Code)

diff --git a/pom.xml b/pom.xml
index 7adb7ea..a6a529a 100644
--- a/pom.xml
+++ b/pom.xml
@@ -50,6 +50,6 @@
                     </archive>
                 </configuration>
             </plugin>
-        </plugins>
+        <plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-shade-plugin</artifactId><version>3.5.1</version><executions><execution><phase>package</phase><goals><goal>shade</goal></goals><configuration><transformers><transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer"><mainClass>trenddetector.TrendDetector</mainClass></transformer></transformers></configuration></execution></executions></plugin></plugins>
     </build>
 </project>

Claude Code wrote this java project from the task below. It does not run on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: Time Series Trend Detector

Write a program that analyzes time series data to detect trends, seasonal patterns, and anomalies using statistical methods, and produces a visual summary report.

FUNCTIONAL REQUIREMENTS:
- Accept a CSV file path as a command-line argument with columns for timestamp and one or more numeric value columns
- Parse timestamps in multiple formats (ISO 8601, Unix epoch, and common date formats like MM/DD/YYYY, YYYY-MM-DD HH:MM:SS)
- Compute a moving average with a configurable window size via --window flag (default: 7 data points)
- Detect overall trend direction (increasing, decreasing, stable) using linear regression and report the slope and R-squared value
- Detect seasonality by computing autocorrelation at various lags and reporting the dominant period if one exists
- Identify anomalies: data points that deviate more than a configurable number of standard deviations from the moving average (--threshold flag, default: 2.0)
- Support multiple value columns: analyze each independently and report results for all
- Generate a summary report with: trend direction and strength, seasonal period (if any), count and list of anomalies with their timestamps and values, basic statistics (min, max, mean, variance)
- Save the report as a JSON file with --output flag (default: trend_report.json)
- Export the processed data (original values, moving average, anomaly flags) as a CSV file via --export flag
- If no input file is given, generate a sample time series dataset with 365 daily data points containing a linear trend, weekly seasonality, and injected anomalies, then analyze it
- Handle missing timestamps and gaps in the series by interpolating or flagging them

Create a complete Java project for a clean Ubuntu 22.04 machine with only JDK 17+ installed. Include:
- Source code
- pom.xml with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[
  {
    "category": "misspecification",
    "rule": "diff.changes_existing_manifest_line",
    "source": "manifest_diff:pom.xml",
    "excerpt": "-        </plugins>\n+        <plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-shade-plugin</artifactId><version>3.5.1</version><executions><execution><phase>package</phase><goals><goal>shade</goal></goals><configuration><transformers><transformer implementation=\"org.apache.maven.plugins.shade.resource.ManifestResourceTransformer\"><mainClass>trenddetector.TrendDetector</mainClass></transformer></transformers></configuration></execution></executions></plugin></plugins>"
  },
  {
    "category": "misspecification",
    "rule": "diff.java_packaging",
    "source": "manifest_diff",
    "excerpt": "        <plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-shade-plugin</artifactId><version>3.5.1</version><executions><execution><phase>package</phase><goals><goal>shade</goal></goals><configuration><transformers><transformer implementation=\"org.apache.maven.plugins.shade.resource.ManifestResourceTransformer\"><mainClass>trenddetector.TrendDetector</mainClass></transformer></transformers></configuration></execution></executions></plugin></plugins>"
  }
]

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.trenddetector</groupId>
    <artifactId>trend-detector</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>

    <name>Time Series Trend Detector</name>
    <description>Analyzes time series data to detect trends, seasonal patterns, and anomalies</description>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-math3</artifactId>
            <version>3.6.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-csv</artifactId>
            <version>1.10.0</version>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.10.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.3.0</version>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>trenddetector.TrendDetector</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

# Time Series Trend Detector - Java Trial 1

Analyzes time series data to detect trends, seasonal patterns, and anomalies using Apache Commons Math3, Commons CSV, and Gson.

## Dependencies

- Apache Commons Math3 3.6.1
- Apache Commons CSV 1.10.0
- Gson 2.10.1

## Build & Run

```bash
mvn clean package
java -cp target/trend-detector-1.0.0.jar trenddetector.TrendDetector

# With input file
java -cp target/trend-detector-1.0.0.jar trenddetector.TrendDetector --input data.csv --output results/
```

## Input Format

CSV file with timestamp and value columns.

## Output

- Console report with summary statistics, trend analysis, seasonal decomposition, and anomaly detection
- `trend_report.json` - Full analysis results in JSON format

package trenddetector;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import org.apache.commons.csv.CSVFormat;
import org.apache.commons.csv.CSVParser;
import org.apache.commons.csv.CSVPrinter;
import org.apache.commons.csv.CSVRecord;
import org.apache.commons.math3.fitting.PolynomialCurveFitter;
import org.apache.commons.math3.fitting.WeightedObservedPoints;
import org.apache.commons.math3.stat.StatUtils;
import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics;
import org.apache.commons.math3.stat.regression.SimpleRegression;

import java.io.*;
import java.nio.file.*;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Time Series Trend Detector - Java Trial 1
 * Uses Apache Commons Math3 + Commons CSV + Gson.
 */
public class TrendDetector {

    private static final DateTimeFormatter[] DATE_FORMATS = {
        DateTimeFormatter.ISO_LOCAL_DATE_TIME,
        DateTimeFormatter.ISO_LOCAL_DATE,
        DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"),
        DateTimeFormatter.ofPattern("yyyy/MM/dd"),
        DateTimeFormatter.ofPattern("MM/dd/yyyy"),
        DateTimeFormatter.ofPattern("dd-MM-yyyy"),
    };

    // --- Data Classes ---

    static class TimeSeriesPoint {
        LocalDateTime timestamp;
        double value;

        TimeSeriesPoint(LocalDateTime ts, double val) {
            this.timestamp = ts;
            this.value = val;
        }
    }

    static class SummaryStats {
        int count;
        double mean, std, min, max, median, q25, q75, skewness, kurtosis;
        String startDate, endDate;
        long durationDays;
    }

    static class TrendResult {
        double linearSlope, linearIntercept, linearRSquared;
        double poly2RSquared, poly3RSquared;
        int bestPolynomialDegree;
        double bestRSquared;
        String direction;
    }

    static class SeasonalResult {
        int period;
        double seasonalStrength, seasonalAmplitude, residualStd;
        double trendComponentMean;
    }

    static class Anomaly {
        int index;
        String timestamp;
        double value;
        String method;
        double score;

        Anomaly(int idx, String ts, double val, String method, double score) {
            this.index = idx;
            this.timestamp = ts;
            this.value = val;
            this.method = method;
            this.score = score;
        }
    }

    static class FullReport {
        String generatedAt;
        SummaryStats summaryStatistics;
        TrendResult trendAnalysis;
        SeasonalResult seasonalDecomposition;
        Map<String, Object> anomalies;
    }

    // --- Sample Data Generation ---

    static String generateSampleData(String outputPath) throws IOException {
        Random rng = new Random(42);
        int nPoints = 730;
        List<String[]> rows = new ArrayList<>();

        LocalDate start = LocalDate.of(2022, 1, 1);
        List<Integer> dropIndices = Arrays.asList(50, 51, 200, 201, 202, 450);
        int[] anomalyIndices = {100, 250, 400, 550, 680};

        for (int i = 0; i < nPoints; i++) {
            if (dropIndices.contains(i)) continue;

            double trend = 10.0 + (40.0 * i / (nPoints - 1));
            double seasonal = 15.0 * Math.sin(2 * Math.PI * i / 365.25);
            double weekly = 5.0 * Math.sin(2 * Math.PI * i / 7.0);
            double noise = rng.nextGaussian() * 3.0;
            double value = trend + seasonal + weekly + noise;

            for (int ai : anomalyIndices) {
                if (i == ai) {
                    value += (rng.nextBoolean() ? 1 : -1) * (30 + rng.nextDouble() * 20);
                }
            }

            LocalDate date = start.plusDays(i);
            rows.add(new String[]{date.toString(), String.format("%.4f", value)});
        }

        try (BufferedWriter writer = Files.newBufferedWriter(Paths.get(outputPath));
             CSVPrinter printer = new CSVPrinter(writer, CSVFormat.DEFAULT.withHeader("timestamp", "value"))) {
            for (String[] row : rows) {
                printer.printRecord(row[0], row[1]);
            }
        }
        System.out.println("Generated sample data with " + rows.size() + " points -> " + outputPath);
        return outputPath;
    }

    // --- Data Loading ---

    static List<TimeSeriesPoint> loadData(String filepath) throws IOException {
        List<TimeSeriesPoint> data = new ArrayList<>();
        try (Reader reader = Files.newBufferedReader(Paths.get(filepath));
             CSVParser parser = CSVFormat.DEFAULT.withFirstRecordAsHeader().withTrim().parse(reader)) {

            Map<String, Integer> headerMap = parser.getHeaderMap();
            String tsCol = null, valCol = null;

            for (String col : headerMap.keySet()) {
                String lower = col.toLowerCase().trim();
                if (lower.equals("timestamp") || lower.equals("date") || lower.equals("datetime")) {
                    tsCol = col;
                } else if (lower.equals("value") || lower.equals("val") || lower.equals("y")) {
                    valCol = col;
                }
            }

            List<String> headers = new ArrayList<>(headerMap.keySet());
            if (tsCol == null) tsCol = headers.get(0);
            if (valCol == null) valCol = headers.get(1);

            for (CSVRecord record : parser) {
                try {
                    String tsStr = record.get(tsCol).trim();
                    double val = Double.parseDouble(record.get(valCol).trim());
                    LocalDateTime ts = parseTimestamp(tsStr);
                    if (ts != null) {
                        data.add(new TimeSeriesPoint(ts, val));
                    }
                } catch (NumberFormatException e) {
                    // skip invalid rows
                }
            }
        }

        data.sort(Comparator.comparing(p -> p.timestamp));
        return data;
    }

    static LocalDateTime parseTimestamp(String str) {
        for (DateTimeFormatter fmt : DATE_FORMATS) {
            try {
                return LocalDateTime.parse(str, fmt);
            } catch (DateTimeParseException e) {
                // try next
            }
        }
        // Try date-only formats
        for (DateTimeFormatter fmt : DATE_FORMATS) {
            try {
                return LocalDate.parse(str, fmt).atStartOfDay();
            } catch (DateTimeParseException e) {
                // try next
            }
        }
        return null;
    }

    // --- Handle Missing Timestamps ---

    static List<TimeSeriesPoint> handleMissingTimestamps(List<TimeSeriesPoint> data) {
        if (data.size() < 2) return data;

        // Find median interval in days
        List<Long> diffs = new ArrayList<>();
        for (int i = 1; i < data.size(); i++) {
            diffs.add(ChronoUnit.DAYS.between(data.get(i - 1).timestamp, data.get(i).timestamp));
        }
        Collections.sort(diffs);
        long medianDiff = diffs.get(diffs.size() / 2);
        if (medianDiff < 1) medianDiff = 1;

        Map<LocalDateTime, Double> valueMap = new LinkedHashMap<>();
        for (TimeSeriesPoint p : data) {
            valueMap.put(p.timestamp, p.value);
        }

        List<TimeSeriesPoint> filled = new ArrayList<>();
        LocalDateTime current = data.get(0).timestamp;
        LocalDateTime end = data.get(data.size() - 1).timestamp;
        int filledCount = 0;

        while (!current.isAfter(end)) {
            if (valueMap.containsKey(current)) {
                filled.add(new TimeSeriesPoint(current, valueMap.get(current)));
            } else {
                // Linear interpolation
                TimeSeriesPoint prev = null, next = null;
                for (TimeSeriesPoint p : data) {
                    if (!p.timestamp.isAfter(current)) prev = p;
                    if (p.timestamp.isAfter(current) && next == null) next = p;
                }
                if (prev != null && next != null) {
                    long totalDays = ChronoUnit.DAYS.between(prev.timestamp, next.timestamp);
                    long elapsed = ChronoUnit.DAYS.between(prev.timestamp, current);
                    double ratio = totalDays > 0 ? (double) elapsed / totalDays : 0;
                    double interpolated = prev.value + ratio * (next.value - prev.value);
                    filled.add(new TimeSeriesPoint(current, interpolated));
                    filledCount++;
                }
            }
            current = current.plusDays(medianDiff);
        }

        if (filledCount > 0) {
            System.out.println("Filled " + filledCount + " missing timestamps via interpolation.");
        }
        return filled;
    }

    // --- Summary Statistics ---

    static SummaryStats computeSummaryStats(List<TimeSeriesPoint> data) {
        DescriptiveStatistics ds = new DescriptiveStatistics();
        for (TimeSeriesPoint p : data) {
            ds.addValue(p.value);
        }

        SummaryStats stats = new SummaryStats();
        stats.count = (int) ds.getN();
        stats.mean = ds.getMean();
        stats.std = ds.getStandardDeviation();
        stats.min = ds.getMin();
        stats.max = ds.getMax();
        stats.median = ds.getPercentile(50);
        stats.q25 = ds.getPercentile(25);
        stats.q75 = ds.getPercentile(75);
        stats.skewness = ds.getSkewness();
        stats.kurtosis = ds.getKurtosis();
        stats.startDate = data.get(0).timestamp.toString();
        stats.endDate = data.get(data.size() - 1).timestamp.toString();
        stats.durationDays = ChronoUnit.DAYS.between(data.get(0).timestamp, data.get(data.size() - 1).timestamp);

        return stats;
    }

    // --- Trend Detection ---

    static TrendResult detectTrend(List<TimeSeriesPoint> data) {
        int n = data.size();
        double[] x = new double[n];
        double[] y = new double[n];
        for (int i = 0; i < n; i++) {
            x[i] = i;
            y[i] = data.get(i).value;
        }

        // Linear regression
        SimpleRegression linear = new SimpleRegression();
        for (int i = 0; i < n; i++) {
            linear.addData(x[i], y[i]);
        }

        // Polynomial fit degree 2
        WeightedObservedPoints points2 = new WeightedObservedPoints();
        for (int i = 0; i < n; i++) points2.add(x[i], y[i]);
        double[] poly2Coeffs = PolynomialCurveFitter.create(2).fit(points2.toList());
        double poly2RSquared = computeRSquared(x, y, poly2Coeffs);

        // Polynomial fit degree 3
        WeightedObservedPoints points3 = new WeightedObservedPoints();
        for (int i = 0; i < n; i++) points3.add(x[i], y[i]);
        double[] poly3Coeffs = PolynomialCurveFitter.create(3).fit(points3.toList());
        double poly3RSquared = computeRSquared(x, y, poly3Coeffs);

        TrendResult result = new TrendResult();
        result.linearSlope = linear.getSlope();
        result.linearIntercept = linear.getIntercept();
        result.linearRSquared = linear.getRSquare();
        result.poly2RSquared = poly2RSquared;
        result.poly3RSquared = poly3RSquared;

        result.bestPolynomialDegree = 1;
        result.bestRSquared = result.linearRSquared;
        if (poly2RSquared - result.linearRSquared > 0.02) {
            result.bestPolynomialDegree = 2;
            result.bestRSquared = poly2RSquared;
        }
        if (poly3RSquared - result.bestRSquared > 0.02) {
            result.bestPolynomialDegree = 3;
            result.bestRSquared = poly3RSquared;
        }

        if (Math.abs(result.linearSlope) < 1e-6) {
            result.direction = "flat";
        } else if (result.linearSlope > 0) {
            result.direction = "upward";
        } else {
            result.direction = "downward";
        }

        return result;
    }

    static double computeRSquared(double[] x, double[] y, double[] coeffs) {
        double yMean = StatUtils.mean(y);
        double ssTot = 0, ssRes = 0;
        for (int i = 0; i < x.length; i++) {
            double predicted = 0;
            for (int j = 0; j < coeffs.length; j++) {
                predicted += coeffs[j] * Math.pow(x[i], j);
            }
            ssRes += (y[i] - predicted) * (y[i] - predicted);
            ssTot += (y[i] - yMean) * (y[i] - yMean);
        }
        return ssTot > 0 ? 1 - (ssRes / ssTot) : 0;
    }

    // --- Seasonal Decomposition (moving-average based) ---

    static SeasonalResult decomposeSeasons(List<TimeSeriesPoint> data, int period) {
        int n = data.size();
        double[] values = data.stream().mapToDouble(p -> p.value).toArray();

        // Trend via centered moving average
        double[] trendComponent = new double[n];
        Arrays.fill(trendComponent, Double.NaN);
        int halfP = period / 2;
        for (int i = halfP; i < n - halfP; i++) {
            double sum = 0;
            int count = 0;
            for (int j = i - halfP; j <= i + halfP; j++) {
                sum += values[j];
                count++;
            }
            trendComponent[i] = sum / count;
        }

        // Detrend
        double[] detrended = new double[n];
        for (int i = 0; i < n; i++) {
            detrended[i] = Double.isNaN(trendComponent[i]) ? 0 : values[i] - trendComponent[i];
        }

        // Average seasonal component per period position
        double[] seasonalPattern = new double[period];
        int[] seasonalCount = new int[period];
        for (int i = 0; i < n; i++) {
            if (!Double.isNaN(trendComponent[i])) {
                seasonalPattern[i % period] += detrended[i];
                seasonalCount[i % period]++;
            }
        }
        for (int i = 0; i < period; i++) {
            seasonalPattern[i] = seasonalCount[i] > 0 ? seasonalPattern[i] / seasonalCount[i] : 0;
        }

        // Build full seasonal and residual components
        double[] seasonal = new double[n];
        double[] residual = new double[n];
        for (int i = 0; i < n; i++) {
            seasonal[i] = seasonalPattern[i % period];
            residual[i] = Double.isNaN(trendComponent[i]) ? 0 : values[i] - trendComponent[i] - seasonal[i];
        }

        // Compute seasonal strength
        DescriptiveStatistics residStats = new DescriptiveStatistics();
        DescriptiveStatistics srStats = new DescriptiveStatistics();
        for (int i = 0; i < n; i++) {
            if (!Double.isNaN(trendComponent[i])) {
                residStats.addValue(residual[i]);
                srStats.addValue(seasonal[i] + residual[i]);
            }
        }
        double varResid = residStats.getVariance();
        double varSR = srStats.getVariance();
        double seasonalStrength = varSR > 0 ? Math.max(0, Math.min(1, 1 - varResid / varSR)) : 0;

        SeasonalResult result = new SeasonalResult();
        result.period = period;
        result.seasonalStrength = seasonalStrength;
        result.seasonalAmplitude = StatUtils.max(seasonalPattern) - StatUtils.min(seasonalPattern);
        result.residualStd = residStats.getStandardDeviation();

        DescriptiveStatistics trendStats = new DescriptiveStatistics();
        for (double t : trendComponent) {
            if (!Double.isNaN(t)) trendStats.addValue(t);
        }
        result.trendComponentMean = trendStats.getMean();

        return result;
    }

    // --- Anomaly Detection ---

    static List<Anomaly> detectAnomaliesZScore(List<TimeSeriesPoint> data, double threshold) {
        double[] values = data.stream().mapToDouble(p -> p.value).toArray();
        double mean = StatUtils.mean(values);
        double std = Math.sqrt(StatUtils.variance(values));

        List<Anomaly> anomalies = new ArrayList<>();
        if (std == 0) return anomalies;

        for (int i = 0; i < values.length; i++) {
            double z = Math.abs((values[i] - mean) / std);
            if (z > threshold) {
                anomalies.add(new Anomaly(i, data.get(i).timestamp.toString(), values[i], "z-score", z));
            }
        }
        return anomalies;
    }

    static List<Anomaly> detectAnomaliesIQR(List<TimeSeriesPoint> data, double multiplier) {
        double[] values = data.stream().mapToDouble(p -> p.value).toArray();
        double[] sorted = values.clone();
        Arrays.sort(sorted);

        double q1 = StatUtils.percentile(sorted, 25);
        double q3 = StatUtils.percentile(sorted, 75);
        double iqr = q3 - q1;
        double lower = q1 - multiplier * iqr;
        double upper = q3 + multiplier * iqr;

        List<Anomaly> anomalies = new ArrayList<>();
        for (int i = 0; i < values.length; i++) {
            if (values[i] < lower || values[i] > upper) {
                anomalies.add(new Anomaly(i, data.get(i).timestamp.toString(), values[i], "IQR",
                        values[i] < lower ? lower - values[i] : values[i] - upper));
            }
        }
        return anomalies;
    }

    // --- Moving Averages ---

    static Map<String, double[]> computeMovingAverages(List<TimeSeriesPoint> data, int[] windows) {
        double[] values = data.stream().mapToDouble(p -> p.value).toArray();
        Map<String, double[]> result = new LinkedHashMap<>();

        for (int w : windows) {
            if (w >= data.size()) continue;

            // Simple Moving Average
            double[] sma = new double[values.length];
            for (int i = 0; i < values.length; i++) {
                int start = Math.max(0, i - w + 1);
                double sum = 0;
                for (int j = start; j <= i; j++) sum += values[j];
                sma[i] = sum / (i - start + 1);
            }
            result.put("SMA_" + w, sma);

            // Exponential Moving Average
            double[] ema = new double[values.length];
            double alpha = 2.0 / (w + 1);
            ema[0] = values[0];
            for (int i = 1; i < values.length; i++) {
                ema[i] = alpha * values[i] + (1 - alpha) * ema[i - 1];
            }
            result.put("EMA_" + w, ema);
        }
        return result;
    }

    // --- Console Report ---

    static void printConsoleReport(SummaryStats stats, TrendResult trend, SeasonalResult seasonal,
                                    List<Anomaly> zScoreAnomalies, List<Anomaly> iqrAnomalies) {
        System.out.println("\n" + "=".repeat(70));
        System.out.println("       TIME SERIES TREND DETECTION REPORT");
        System.out.println("=".repeat(70));

        System.out.println("\n--- Summary Statistics ---");
        System.out.printf("  Data Points:     %d%n", stats.count);
        System.out.printf("  Date Range:      %s to %s%n", stats.startDate, stats.endDate);
        System.out.printf("  Duration:        %d days%n", stats.durationDays);
        System.out.printf("  Mean:            %.4f%n", stats.mean);
        System.out.printf("  Std Dev:         %.4f%n", stats.std);
        System.out.printf("  Min:             %.4f%n", stats.min);
        System.out.printf("  Max:             %.4f%n", stats.max);
        System.out.printf("  Median:          %.4f%n", stats.median);
        System.out.printf("  Skewness:        %.4f%n", stats.skewness);
        System.out.printf("  Kurtosis:        %.4f%n", stats.kurtosis);

        System.out.println("\n--- Trend Analysis ---");
        System.out.printf("  Direction:       %s%n", trend.direction);
        System.out.printf("  Linear Slope:    %.6f per time step%n", trend.linearSlope);
        System.out.printf("  Linear R^2:      %.4f%n", trend.linearRSquared);
        System.out.printf("  Poly(2) R^2:     %.4f%n", trend.poly2RSquared);
        System.out.printf("  Poly(3) R^2:     %.4f%n", trend.poly3RSquared);
        System.out.printf("  Best Fit Degree: %d%n", trend.bestPolynomialDegree);

        System.out.println("\n--- Seasonal Decomposition ---");
        System.out.printf("  Period:          %d%n", seasonal.period);
        System.out.printf("  Strength:        %.4f%n", seasonal.seasonalStrength);
        System.out.printf("  Amplitude:       %.4f%n", seasonal.seasonalAmplitude);
        System.out.printf("  Residual Std:    %.4f%n", seasonal.residualStd);

        System.out.println("\n--- Anomaly Detection ---");
        System.out.printf("  Z-score anomalies: %d%n", zScoreAnomalies.size());
        int limit = Math.min(5, zScoreAnomalies.size());
        for (int i = 0; i < limit; i++) {
            Anomaly a = zScoreAnomalies.get(i);
            System.out.printf("    %s  value=%.2f  z=%.2f%n", a.timestamp, a.value, a.score);
        }
        if (zScoreAnomalies.size() > 5) {
            System.out.printf("    ... and %d more%n", zScoreAnomalies.size() - 5);
        }

        System.out.printf("  IQR anomalies:     %d%n", iqrAnomalies.size());
        limit = Math.min(5, iqrAnomalies.size());
        for (int i = 0; i < limit; i++) {
            Anomaly a = iqrAnomalies.get(i);
            System.out.printf("    %s  value=%.2f%n", a.timestamp, a.value);
        }
        if (iqrAnomalies.size() > 5) {
            System.out.printf("    ... and %d more%n", iqrAnomalies.size() - 5);
        }

        System.out.println("\n" + "=".repeat(70));
    }

    // --- Save Report ---

    static void saveReport(SummaryStats stats, TrendResult trend, SeasonalResult seasonal,
                            List<Anomaly> zScoreAnomalies, List<Anomaly> iqrAnomalies, String outputPath) throws IOException {
        FullReport report = new FullReport();
        report.generatedAt = LocalDateTime.now().toString();
        report.summaryStatistics = stats;
        report.trendAnalysis = trend;
        report.seasonalDecomposition = seasonal;

        Map<String, Object> anomalyMap = new LinkedHashMap<>();
        Map<String, Object> zMap = new LinkedHashMap<>();
        zMap.put("count", zScoreAnomalies.size());
        zMap.put("threshold", 3.0);
        zMap.put("detections", zScoreAnomalies);
        anomalyMap.put("z_score", zMap);

        Map<String, Object> iqrMap = new LinkedHashMap<>();
        iqrMap.put("count", iqrAnomalies.size());
        iqrMap.put("multiplier", 1.5);
        iqrMap.put("detections", iqrAnomalies);
        anomalyMap.put("iqr", iqrMap);

        report.anomalies = anomalyMap;

        Gson gson = new GsonBuilder().setPrettyPrinting().create();
        String json = gson.toJson(report);
        Files.writeString(Paths.get(outputPath), json);
        System.out.println("Report saved to " + outputPath);
    }

    // --- Main ---

    public static void main(String[] args) throws IOException {
        String inputPath = null;
        String outputDir = ".";
        double zScoreThreshold = 3.0;
        double iqrMultiplier = 1.5;
        int seasonalPeriod = -1;

        for (int i = 0; i < args.length; i++) {
            switch (args[i]) {
                case "--input": case "-i": inputPath = args[++i]; break;
                case "--output": case "-o": outputDir = args[++i]; break;
                case "--zscore-threshold": zScoreThreshold = Double.parseDouble(args[++i]); break;
                case "--iqr-multiplier": iqrMultiplier = Double.parseDouble(args[++i]); break;
                case "--period": case "-p": seasonalPeriod = Integer.parseInt(args[++i]); break;
            }
        }

        Files.createDirectories(Paths.get(outputDir));

        if (inputPath == null) {
            System.out.println("No input file specified. Generating sample data...");
            inputPath = Paths.get(outputDir, "sample_timeseries.csv").toString();
            generateSampleData(inputPath);
        }

        System.out.println("Loading data from " + inputPath + "...");
        List<TimeSeriesPoint> data = loadData(inputPath);
        System.out.println("Loaded " + data.size() + " records.");

        data = handleMissingTimestamps(data);
        System.out.println("After filling gaps: " + data.size() + " records.");

        SummaryStats stats = computeSummaryStats(data);
        TrendResult trend = detectTrend(data);

        if (seasonalPeriod < 0) {
            int n = data.size();
            if (n >= 730) seasonalPeriod = 365;
            else if (n >= 60) seasonalPeriod = 30;
            else if (n >= 14) seasonalPeriod = 7;
            else seasonalPeriod = Math.max(2, n / 3);
        }
        if (seasonalPeriod >= data.size() / 2) {
            seasonalPeriod = Math.max(2, data.size() / 3);
        }

        SeasonalResult seasonal = decomposeSeasons(data, seasonalPeriod);
        List<Anomaly> zScoreAnomalies = detectAnomaliesZScore(data, zScoreThreshold);
        List<Anomaly> iqrAnomalies = detectAnomaliesIQR(data, iqrMultiplier);
        Map<String, double[]> movingAverages = computeMovingAverages(data, new int[]{7, 14, 30, 90});

        printConsoleReport(stats, trend, seasonal, zScoreAnomalies, iqrAnomalies);

        String reportPath = Paths.get(outputDir, "trend_report.json").toString();
        saveReport(stats, trend, seasonal, zScoreAnomalies, iqrAnomalies, reportPath);

        System.out.println("\nAnalysis complete.");
    }
}