package BankServices;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;



public class Bank {

    private String n;
private int num=1;
private double v=0;
private double prelievo;
private double soldi;
Account a;
List<Double> prelievi = new LinkedList<>();
List<Double> s = new LinkedList<>();
HashMap<Integer, Account > accounts = new HashMap<>();
public Bank(String n) {
    this.n=n;
    }

    public String getName() {
        return n;
    }

    public int createAccount(String name, int date, double initial) {
        a= new Account(name,date,initial);
        int numd = num++;
        accounts.put(numd, a);
        return numd;
    }

    public Account deleteAccount(int code, int date) throws InvalidCode {
        if ( ! accounts.containsKey(code)) {throw new InvalidCode();}
     s.add( accounts.get(code).getValue());

     if ( date < accounts.get(code).getDate()){
            date = accounts.get(code).getDate();}
     accounts.remove(code);

        return accounts.get(code);
    }

    public Account getAccount(int code) throws InvalidCode {

        if(! accounts.containsKey(code)){throw new InvalidCode();}
        return accounts.get(code);
    }

    public void deposit(int code, int date, double value) throws InvalidCode {
    if (!accounts.containsKey(code)){throw new InvalidCode();}
    else{
     double v=  accounts.get(code).getInitial() + value;
    a.addValue(v);
    if ( date < accounts.get(code).getDate()){
        date = accounts.get(code).getDate();

    }
    }
    }



    public void withdraw(int code, int date, double value) throws InvalidCode, InvalidValue {
    if(! accounts.containsKey(code)){throw new InvalidCode();}
    if( value < accounts.get(code).getValue()){
        throw new InvalidValue();}
    else {

        prelievi.add(accounts.get(code).getValue() - value);
        if ( date < accounts.get(code).getDate()){
            date = accounts.get(code).getDate();

        }
    }
    }

    public void transfer(int fromCode, int toCode, int date, double value) throws InvalidCode, InvalidValue {
    if (! accounts.containsKey(fromCode)|| ! accounts.containsKey(toCode) ){
        throw new InvalidCode();}

    double s  = accounts.get(fromCode).getValue();
    if ( s > accounts.get(toCode).getValue()){throw new InvalidValue();}
    else  {
        double t=accounts.get(toCode).getValue();
        t +=s;

    }

    }

    public double getTotalDeposit() {
        double sum=0;
        Collection<Account> at = accounts.values();
        Iterator<Account> it = at.iterator();
        while (it.hasNext()){
            Account a = it.next();
            sum += a.getValue();

        }
        return sum;
    }

    public List<Account> getAccounts() {
        //List<Account> p = new LinkedList<Account>(accounts.keySet());

        return  null;
    }

    public List<Account> getAccountsByBalance(double low, double high) {

        List<Account> sal = new LinkedList<Account>();
        Collection<Account> at = accounts.values();
        Iterator<Account> it = at.iterator();
        while (it.hasNext()){
            Account a = it.next();
            if (a.getValue() > low && a.getValue() < high ){
            sal.add(a);
            }
            }
        return sal;
    }

    public double getPerCentHigher(double min) {
        double per;
        double c=0;
        Collection<Account> at = accounts.values();
        Iterator<Account> it = at.iterator();
        while (it.hasNext()){
            Account a = it.next();
            if ( a.getValue()>min){
            c++;

            }}
        per = c/ at.size()*100;
        return per ;

}}