DataBase

package pgdp.net;

import java.io.*;
import java.nio.file.Path;
import java.util.*;
import java.util.concurrent.atomic.AtomicLong;

public class PinguDatabase {
  static Path dataFile = Path.of("db", "penguins.csv");
  private static Map<Long, DatingPingu> data = new HashMap<>();
  private static AtomicLong newID = null;

  public boolean add(DatingPingu datingPingu) {
    synchronized (data) {
      if (!data.containsKey(datingPingu.getId())) {
        data.put(datingPingu.getId(), datingPingu);
        PinguDatabase pinguDatabase = new PinguDatabase();
        pinguDatabase.clearFile();
        data.entrySet().stream().forEach(id ->
          pinguDatabase.add(id.getValue()));
        pinguDatabase.flush();
        return true;
      }
      return false;
    }
  }

  public Optional<DatingPingu> lookupById(long id) {
    synchronized (data) {
      if (id < 0) {
        throw new IllegalArgumentException("Id is invalid.");
      }
      if (data.containsKey(id)) {
        Optional<DatingPingu> res = Optional.of(data.get(id));
        return res;
      }
      return Optional.empty();
    }
  }

  public List<DatingPingu> findMatchesFor(SeachRequest request) {
    synchronized (data) {
      List<DatingPingu> penguins = new ArrayList<>();
      data.entrySet().stream().forEach(penguin -> {
        if (penguin.getValue().getSexualOrientation().equals(request.getSexualOrientation())
          && penguin.getValue().getAge() >= request.getMinAge() && penguin.getValue().getAge() <= request.getMaxAge()
          && penguin.getValue().getHobbies().stream().anyMatch(hobby -> request.getHobbies().contains(hobby)))
          penguins.add(penguin.getValue());
      });
      return penguins;
    }
  }

  public boolean initialize() {
    try {
      BufferedReader br = new BufferedReader(new FileReader(String.valueOf(dataFile)));
      String line = "";
      long maxID = 0;
      while ((line = br.readLine()) != null) {
        if (line.length() == 0) {
          continue;
        }
        DatingPingu datingPingu = DatingPingu.parse(line);
        synchronized (data) {
          data.putIfAbsent(datingPingu.getId(), datingPingu);
          if (maxID < datingPingu.getId()) {
            maxID = datingPingu.getId();
          }
        }
      }
      newID.addAndGet(maxID + 1);
      return true;
    } catch (IOException ex) {
      return false;
    }
  }

  public long getNewId() {
    if (newID == null)
      return 0;
    return newID.getAndIncrement();
  }

  public boolean flush() {
    try {
      BufferedWriter writer = new BufferedWriter(new FileWriter(String.valueOf(dataFile)));
      synchronized (data) {
        data.entrySet().stream().forEach(penguin -> {
          try {
            writer.write(penguin.getValue().toCsvRow());
            writer.newLine();
          } catch (IOException e) {
            e.printStackTrace();
          }
        });
      }
      return true;
    } catch (IOException ex) {
      return false;
    }
  }

  public void clear() {
    synchronized (data) {
      data.clear();
    }
  }

  public void delete(Long id) {
    synchronized (data) {
      if (data.containsKey(id)) {
        data.remove(id);
        PinguDatabase pinguDatabase = new PinguDatabase();
        data.entrySet().stream().forEach(penguin -> {
          pinguDatabase.add(penguin.getValue());
        });
        pinguDatabase.flush();
      }
    }
  }

  public boolean clearFile() {
    try {
      PrintWriter writer = new PrintWriter(String.valueOf(dataFile));
      writer.print("");
      writer.close();
      return true;
    } catch (IOException e) {
      System.err.println(e.getMessage());
    }
    return false;
  }

  // TODO
}