package com.narrowtux.fmm.model;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import javafx.beans.property.ObjectProperty;
import javafx.beans.property.SimpleObjectProperty;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
import javafx.collections.FXCollections;
import javafx.collections.ObservableSet;
import org.sat4j.core.VecInt;
import org.sat4j.minisat.SolverFactory;
import org.sat4j.specs.ContradictionException;
import org.sat4j.specs.ISolver;
import org.sat4j.tools.ModelIterator;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.*;
import java.util.stream.Collectors;
public class Modpack {
private static final int RECURSION_LIMIT = 20;
private StringProperty name = new SimpleStringProperty();
private ObservableSet<ModReference> mods = FXCollections.observableSet(new LinkedHashSet<ModReference>());
private ObjectProperty<Path> path = new SimpleObjectProperty<>();
public Modpack(String name, Path path) {
setName(name);
setPath(path);
nameProperty().addListener((obs, ov, nv) -> {
// sanity check. no slashes allowed
if (nv == null || nv.isEmpty() || nv.contains("/")) {
setName(ov);
return;
}
Path newPath = getPath().getParent().resolve(nv);
try {
Files.move(getPath(), newPath);
setPath(newPath);
for (ModReference mod : getMods()) {
String fileName = mod.getMod().getPath().getFileName().toString();
Path modNewPath = mod.getMod().getPath().getParent().getParent().resolve(nv).resolve(fileName);
mod.getMod().setPath(modNewPath);
}
} catch (IOException e) {
e.printStackTrace();
setName(ov);
}
});
}
public String getName() {
return name.get();
}
public void setName(String name) {
this.name.set(name);
}
public StringProperty nameProperty() {
return name;
}
public Path getPath() {
return path.get();
}
public ObjectProperty<Path> pathProperty() {
return path;
}
public void setPath(Path path) {
this.path.set(path);
}
public ObservableSet<ModReference> getMods() {
return mods;
}
@Override
public String toString() {
return "Modpack{" +
"name=" + getName() +
", mods=" + mods +
'}';
}
public void writeModList() {
writeModList(false);
}
public void writeModList(boolean writeVersion) {
writeModList(getPath().resolve("mod-list.json"), writeVersion, getMods().toArray(new ModReference[0]));
}
public static void writeModList(Path file, boolean writeVersion, ModReference ... mods) {
JsonObject root = new JsonObject();
JsonArray modList = new JsonArray();
JsonObject baseMod = new JsonObject();
baseMod.addProperty("name", "base");
baseMod.addProperty("enabled", true);
modList.add(baseMod);
for (ModReference mod : mods) {
JsonObject modInfo = new JsonObject();
modInfo.addProperty("name", mod.getMod().getName());
modInfo.addProperty("enabled", mod.getEnabled());
if (writeVersion) {
modInfo.addProperty("version", mod.getMod().getVersion().toString());
}
modList.add(modInfo);
}
root.add("mods", modList);
try {
Gson gson = new Gson();
String json = gson.toJson(root);
FileWriter writer = new FileWriter(file.toFile());
writer.write(json);
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public List<Set<Mod>> resolveDependencies() {
Set<Mod> confirmedMods = getMods().stream().map(ModReference::getMod).collect(Collectors.toSet());
try {
return resolveDependencies(0, confirmedMods);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
public List<Set<Mod>> resolveDependencies(int recursionInterval, Set<Mod> confirmedMods) throws Exception {
if (recursionInterval > RECURSION_LIMIT) {
throw new Exception("Recursion limit reached");
}
recursionInterval ++;
List<Set<Mod>> solutions = new LinkedList<>();
List<ModDependency> deps = new LinkedList<>();
confirmedMods.forEach(mod -> deps.addAll(mod.getDependencies().stream().filter(dep -> !dep.getOptional()).collect(Collectors.toList())));
for (Mod mod : confirmedMods) {
List<ModDependency> satisfied = new LinkedList<>();
for (ModDependency dep : deps) {
if (dep.getDependencyName().equals(mod.getName())) {
if (dep.getMatchedVersion() == null || dep.getMatchedVersion().matches(mod.getVersion())) {
satisfied.add(dep);
}
}
}
deps.removeAll(satisfied);
}
if (deps.isEmpty()) {
solutions.add(confirmedMods);
return solutions;
}
ISolver solver = SolverFactory.newDefault();
solver.setKeepSolverHot(true);
Set<String> names = deps.stream().map(ModDependency::getDependencyName).collect(Collectors.toSet());
List<Mod> matchedMods = new LinkedList<>();
Datastore store = Datastore.getInstance();
final boolean[] modNotFound = {false};
deps.stream().forEach(dep -> {
final int[] found = {0};
VecInt clause = new VecInt();
store.getMods().values().stream()
.filter(mod -> dep.getMatchedVersion() == null || dep.getMatchedVersion().matches(mod.getVersion()))
.filter(mod -> dep.getDependencyName().equals(mod.getName()))
.forEach(mod -> {
found[0]++;
if (!matchedMods.contains(mod)) {
matchedMods.add(mod);
}
int literal = matchedMods.indexOf(mod) + 1;
if (!clause.contains(literal)) {
clause.push(literal);
}
});
if (found[0] == 0) {
modNotFound[0] = true;
System.out.println(getName() + ": couldn't find mod for " + dep);
}
try {
solver.addClause(clause);
} catch (ContradictionException e) {
e.printStackTrace();
}
});
if (modNotFound[0]) {
System.out.println(getName() + ": one or more mods couldn't be found");
return null;
}
for (String name : names) {
VecInt vector = new VecInt();
matchedMods.stream().filter(mod -> mod.getName().equals(name)).forEach(mod -> {
int literal = matchedMods.indexOf(mod) + 1;
if (!vector.contains(literal)) {
vector.push(literal);
}
});
try {
solver.addExactly(vector, 1);
} catch (ContradictionException e) {
System.out.println(vector);
e.printStackTrace();
return null;
}
}
ModelIterator iter = new ModelIterator(solver);
for (int interval = 0; interval < RECURSION_LIMIT; interval++) {
if (iter.isSatisfiable()) {
Set<Mod> solution = new HashSet<>(confirmedMods);
for (int v : iter.model()) {
if (v > 0) {
Mod mod = matchedMods.get(v - 1);
solution.add(mod);
}
}
List<Set<Mod>> result = resolveDependencies(recursionInterval, solution);
if (result.size() != 0) {
solutions.addAll(result);
}
} else {
return solutions;
}
}
return solutions;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Modpack modpack = (Modpack) o;
if (!name.equals(modpack.name)) return false;
return path.equals(modpack.path);
}
@Override
public int hashCode() {
int result = name.hashCode();
result = 31 * result + path.hashCode();
return result;
}
}
