package model;

import IO.XLBufferedReader;
import expr.Environment;
import util.XLException;

import java.io.FileNotFoundException;
import java.util.Map;
import java.util.Observable;
import java.util.TreeMap;
import java.util.regex.Pattern;

public class Sheet extends Observable implements Environment {

  private final ExpCellFactory expCF;
  private final CommentCellFactory commentCF;
  private final ErrCellFactory errCF;
  private Map<String, Cell> cellMap;

  public Sheet() {
    cellMap = new TreeMap<>();
    expCF = new ExpCellFactory();
    commentCF = new CommentCellFactory();
    errCF = new ErrCellFactory();
  }

  public void load(String filename) throws FileNotFoundException {
    XLBufferedReader bufferedReader = new XLBufferedReader(filename);
    cellMap = new TreeMap<>();
    bufferedReader.load(this);
    setChanged();
    notifyObservers(cellMap);
  }

  // När du ska skicka errors gör notyifyObserver("ErrorMeddelande")
  public void put(String address, String value) {
    if (!isValidAddress(address)) {
      notifyObservers("Not a valid address!");
    } else {
      try {
        if (value.isEmpty()) {
          clear(address);
        } else if (value.charAt(0) == '#') {
          CommentCell cell = (CommentCell) commentCF.cell(value);
          cellMap.put(address, cell);
        } else {
          try {
            ExpCell cell = (ExpCell) expCF.cell(value);
            cellMap.put(address, cell);
          } catch (Exception e) {
            throw new XLException(e.getMessage());
          }
        }
      } catch (Exception es) {
        setChanged();
        notifyObservers(es.getMessage());
      }
      setChanged();
      notifyObservers(cellMap);
    }
  }

  private boolean isValidAddress(String address) {
    address = address.toLowerCase();
    return Pattern.matches("[a-h][1][0]|[a-h][1-9]", address);
  }

  // Om det är en CommentCell returnera cellens värde utan #
  // Om det är en ExprCell returnera cellens slutgiltiga värde t.ex. 1+3 = 6
  // Vad händer om tom sträng
  public String getValue(String address) {
    Cell cell = cellMap.getOrDefault(address, null);
    if (cell instanceof CommentCell) {
      return cell.toString().substring(1);
    } else {
      try {
        ErrCell tempErr = (ErrCell) errCF.cell(null);
        cellMap.put(address, tempErr);
        Environment env = cellAddress -> cellMap.get(cellAddress).value(this);

        Double value = cell.value(env);
        cellMap.put(address, cell);
        return value.toString();
      } catch (Exception e) {
        clear(address);
        setChanged();
        notifyObservers(e.getMessage());
      }
    }
    return "";
  }

  // Om det är en CommentCell returnera cellens kommentar med #
  // Om det är en ExprCell returnera cellens uttryck t.ex. "1+3"
  public String getExpression(String address) {
    Cell cell = cellMap.getOrDefault(address, null);
    if (cell != null) {
      return cell.toString();
    } else {
      return "";
    }
  }

  public void clear(String address) {
    cellMap.remove(address);
    setChanged();
    notifyObservers(cellMap);
  }

  public void clearAll() {
    cellMap = new TreeMap<>();
    setChanged();
    notifyObservers(cellMap);
  }

  @Override
  public double value(String name) {
    var value = cellMap.getOrDefault(name, null).value(this);
    if (value != null) {
      return value;
    } else {
      notifyObservers("No such value");
      return 0.0;
    }
  }

  public Map getCellMap() {
    return cellMap;
  }
}