// Load the dataset
Table wine = Table.read().csv("wine.csv");

// Part A: Display summary statistics
System.out.println("Summary Statistics:");
System.out.println(wine.summary());

// Part B: Create a histogram of wine quality distribution
Figure qualityHist = Histogram.create("Wine Quality Distribution", wine, "quality");
Plot.show(qualityHist);

// Part B continued: Create a scatter plot of alcohol vs quality
Figure alcoholScatter = ScatterPlot.create("Alcohol vs Quality", wine, "alcohol", "quality");
Plot.show(alcoholScatter);

// Provided: Group wines by quality level
Table qualityGroups = wine.summarize(
    "alcohol", AggregateFunctions.mean,
    "pH", AggregateFunctions.mean,
    "volatile acidity", AggregateFunctions.mean
).by("quality");
System.out.println("\nCharacteristics by quality level:");
System.out.println(qualityGroups);

// Assume `wine` is your Tablesaw Table already loaded.
Table wine = Table.read().csv("wine.csv");

// Convert Tablesaw table to SMILE DataFrame
String[] colNames = wine.columnNames().toArray(String[]::new);
double[][] data = wine.as().doubleMatrix();
DataFrame df = DataFrame.of(data, colNames);

// Convert quality to IntVector (classification target)
IntVector quality = IntVector.of("quality", df.doubleVector("quality").stream()
    .mapToInt(d -> (int) d)
    .toArray());
df = df.drop("quality").merge(quality);

// Split data into training and test sets (80/20 split)
int n = df.nrows();
int[] indices = IntStream.range(0, n).toArray();
MathEx.permutate(indices);
int splitIndex = (int)(n * 0.8);

DataFrame trainDf = df.slice(0, splitIndex);
DataFrame testDf = df.slice(splitIndex, n);

// Part A: Train a Random Forest model using SMILE
int[] yTrain = trainDf.intVector("quality").toIntArray();
double[][] xTrain = trainDf.drop("quality").toArray();

RandomForest rf = RandomForest.fit(xTrain, yTrain);

// Part B: Calculate and display model accuracy
int[] yTrue = testDf.intVector("quality").toIntArray();
double[][] xTest = testDf.drop("quality").toArray();

int[] yPred = rf.predict(xTest);
double accuracy = Accuracy.of(yTrue, yPred);

System.out.printf("SMILE Random Forest Accuracy: %.2f%%\n", accuracy * 100);

Table wine = Table.read().csv("wine.csv");

// Convert to Weka format
ArrayList<Attribute> attributes = new ArrayList<>();
for (String col : wine.columnNames()) {
    if (!col.equals("quality")) {
        attributes.add(new Attribute(col));
    }
}

IntColumn qualityCol = (IntColumn) wine.intColumn("quality");
int minQuality = (int) qualityCol.min();
int maxQuality = (int) qualityCol.max();
ArrayList<String> qualityVals = new ArrayList<>();
for (int i = minQuality; i <= maxQuality; i++) {
    qualityVals.add(String.valueOf(i));
}
attributes.add(new Attribute("quality", qualityVals));

Instances wData = new Instances("Wine", attributes, wine.rowCount());
wData.setClassIndex(wData.numAttributes() - 1);

for (int i = 0; i < wine.rowCount(); i++) {
    double[] vals = new double[wData.numAttributes()];
    for (int j = 0; j < wine.columnCount() - 1; j++) {
        vals[j] = ((NumberColumn<?, ?>) wine.column(j)).getDouble(i);
    }
    vals[wData.numAttributes() - 1] = qualityVals.indexOf(String.valueOf(qualityCol.get(i)));
    wData.add(new DenseInstance(1.0, vals));
}

// Split data
int trainSize = (int) Math.round(wData.numInstances() * 0.8);
Instances train = new Instances(wData, 0, trainSize);
Instances test = new Instances(wData, trainSize, wData.numInstances() - trainSize);

// Train Weka Random Forest and calculate accuracy
RandomForest wekaRf = new RandomForest();

try {
    wekaRf.buildClassifier(train);

    Evaluation eval = new Evaluation(train);
    eval.evaluateModel(wekaRf, test);

    System.out.printf("Weka Random Forest Accuracy: %.2f%%\n", eval.pctCorrect());

    // Compare models
    System.out.println("\nModel Comparison Complete!");
    System.out.println("Which model performed better? Analyze the results above.");

} catch (Exception e) {
    e.printStackTrace();
}

public static ArrayList<Integer> a(ArrayList<Integer> a) {

    ArrayList<Integer> b = new ArrayList<>();

    for (int d = 0; d < a.size(); d++) {
        int c = a.get(d);
        if (c % 2 == 0) {
            b.add(c);
        }
    }

    return b;
}

ArrayList<Integer> a = new ArrayList<>();
a.add(1);
a.add(2);
a.add(3);
a.add(4);
a.add(5);
a.add(6);

ArrayList<Integer> b = a(a);
System.out.println("Even numbers: " + b);

import java.util.HashSet;
import java.util.Set;

Set<Integer> i(Set<Integer> a, Set<Integer> b) {
    Set<Integer> r = new HashSet<>();
    for (Integer x : a) {
        if (b.contains(x)) {
            r.add(x);
        }
    }
    return r;
}

Set<Integer> a = new HashSet<>();
a.add(1);
a.add(2);
a.add(3);

Set<Integer> b = new HashSet<>();
b.add(2);
b.add(3);
b.add(4);

Set<Integer> r = i(a, b);
System.out.println(r);

import java.util.ArrayDeque;
import java.util.Deque;

Deque<String> ℓ = new ArrayDeque<>();

ℓ.addLast("Alice");
ℓ.addLast("Bob");
ℓ.addLast("Charlie");

ℓ.addFirst("VIP");

ℓ.removeFirst();

System.out.println("Front: " + ℓ.peekFirst());
System.out.println("Back: " + ℓ.peekLast());
System.out.println("Size: " + ℓ.size());

import java.util.HashSet;
import java.util.Random;
import java.util.Set;

Set<Integer> s = new HashSet<>();
Random r = new Random();

while (s.size() < 10) {
    int i = 1900000 + r.nextInt(100000);
    s.add(i);
}

System.out.println("IDs: " + s);

int x = 1901234;
System.out.println("Has " + x + "? " + s.contains(x));

int a = 1;

public void increment(int b) {
    b += 1;
}

increment(a);
System.out.println(a); // will print out 1

import org.knowm.xchart.*;
import org.knowm.xchart.BitmapEncoder.BitmapFormat;
import java.util.*;
import java.io.*;

// Sample data
List<Integer> xData = Arrays.asList(0, 1, 2, 3, 4);
List<Double> yData = Arrays.asList(2.0, 1.5, 3.0, 2.5, 4.0);

// Create chart
XYChart chart = new XYChartBuilder().width(600).height(400).title("Sample Line Chart").xAxisTitle("X").yAxisTitle("Y").build();
chart.addSeries("My Data", xData, yData);

// Save to byte array output stream
ByteArrayOutputStream baos = new ByteArrayOutputStream();
BitmapEncoder.saveBitmap(chart, baos, BitmapFormat.PNG);

// Return the image bytes for the notebook to display inline
baos.toByteArray();