//Guarda este código en un archivo llamado Main.java
//package ....clientes;

import java.io.*;
import java.util.*;

public class Main {

    public static Scanner keyboard = new Scanner(System.in);
    public static PrintStream out = System.out;

    public static void pause_screen(String mensage) {
        out.print(mensage + "\nPresiona <ENTER> para continuar . . . ");
        keyboard.nextLine();
        out.println();
    }

    public static String read_str(String message) {
        out.print(message + ": ");
        return keyboard.nextLine();
    }

    public static int read_integer(String message) {
        try {
            return Integer.parseInt(read_str(message));
        } catch (NumberFormatException e) {
            out.print("N\u00FAmero incorrecto");
            return read_integer(message);
        }
    }

    public static float read_decimal(String message) {
        try {
            return Float.parseFloat(read_str(message));
        } catch (NumberFormatException e) {
            out.print("N\u00FAmero incorrecto. Ingr\u00E9salo nuevamente: ");
            return read_decimal(message);
        }
    }

    public static String path = "clientes.dat";

    public static void main(String[] args) {

        ForEachFunction<Cliente> print = new ForEachFunction<Cliente>() {
            @Override
            public void call(Cliente cliente, Object params) {
                out.println(cliente);
                int[] counter = (int[]) params;
                counter[0]++;
            }
        };
        ForEachFunction<Cliente> printOnFile = new ForEachFunction<Cliente>() {
            @Override
            public void call(Cliente cliente, Object params) {
                PrintStream file_stream = (PrintStream) params;
                file_stream.print(cliente.getNumero_de_cuenta() + "\t");
                file_stream.print(cliente.getNombre() + "\t");
                file_stream.print(cliente.getBalance() + "\n");
            }
        };
        if(!System.getProperties().get("os.name").equals("Linux") && System.console()!=null)
            try {
                out = new PrintStream(System.out, true, "CP850");
                keyboard = new Scanner(System.in, "CP850");
            } catch (UnsupportedEncodingException e) {}
        BinaryTree<Cliente> root = null;
        Cliente datum = null, cliente;
        int[] counter = {0};
        int i, main_option, suboption;
        String[] fields;
        try {
            Scanner file_stream = new Scanner(new FileReader(path));
            while (file_stream.hasNextLine()) {
                fields = file_stream.nextLine().split("\t");
                cliente = new Cliente();
                cliente.setNumero_de_cuenta(fields[0]);
                cliente.setNombre(fields[1]);
                cliente.setBalance(Float.parseFloat(fields[2]));
                root = BinaryTree.insert(root, cliente);
            }
            file_stream.close();
        } catch (FileNotFoundException e) {}
        cliente = new Cliente();
        do {
            out.println("MEN\u00DA");
            out.println("1.- Altas");
            out.println("2.- Consultas");
            out.println("3.- Actualizaciones");
            out.println("4.- Bajas");
            out.println("5.- Listar en preorden");
            out.println("6.- Listar en inorden");
            out.println("7.- Listar en postorden");
            out.println("8.- Salir");
            do {
                main_option = read_integer ("Selecciona una opci\u00F3n");
                if(main_option<1 || main_option>8)
                    out.println("Opci\u00F3n incorrecta");
            } while (main_option<1 || main_option>8);
            out.println();
            if (root==null && main_option!=1 && main_option!=7) {
                pause_screen("No hay registros.\n");
                continue;
            }
            if (main_option<5) {
                cliente.setNumero_de_cuenta(read_str ("Ingresa el numero de cuenta del cliente"));
                datum = BinaryTree.search (root, cliente);
                if (datum!=null) {
                    out.println();
                    print.call(datum, counter);
                }
            }
            if (main_option==1 && datum!=null)
                out.println("El registro ya existe.");
            else if (main_option>=2 && main_option<=4 && datum==null)
                out.println("\nRegistro no encontrado.");
            else switch (main_option) {
            case 1:
                cliente.setNombre(read_str ("Ingresa el nombre"));
                cliente.setBalance(read_decimal ("Ingresa el balance"));
                root = BinaryTree.insert(root, cliente);
                cliente = new Cliente();
                out.println("\nRegistro agregado correctamente.");
                break;
            case 3:
                out.println("Men\u00FA de actualizaci\u00F3n de campos");
                out.println("1.- nombre");
                out.println("2.- balance");
                do {
                    suboption = read_integer ("Selecciona el n\u00FAmero de campo a modificar");
                    if (suboption<1 || suboption>2)
                        out.println("Opci\u00F3n incorrecta");
                } while (suboption<1 || suboption>2);
                switch (suboption) {
                    case 1:
                        datum.setNombre(read_str ("Ingresa el nuevo nombre"));
                        break;
                    case 2:
                        datum.setBalance(read_decimal ("Ingresa el nuevo balance"));
                        break;
                }
                out.println("\nRegistro actualizado correctamente.");
                break;
            case 4:
                root = BinaryTree.remove(root, datum);
                out.println("Registro eliminado correctamente.");
                break;
            case 5:
                counter[0] = 0;
                BinaryTree.preorder(root, print, counter);
                out.println("Total de registros: " + counter[0] + ".");
                break;
            case 6:
                counter[0] = 0;
                BinaryTree.inorder(root, print, counter);
                out.println("Total de registros: " + counter[0] + ".");
                break;
            case 7:
                counter[0] = 0;
                BinaryTree.postorder(root, print, counter);
                out.println("Total de registros: \" + counter[0] + ".");
                break;
            }
            if (main_option<8 && main_option>=1)
                pause_screen("");
        } while (main_option!=8);
        try {
            PrintStream output_stream = new PrintStream(path);
            BinaryTree.inorder(root, printOnFile, output_stream);
            output_stream.close();
        } catch (FileNotFoundException e) {}
    }
}

interface ForEachFunction<T extends Comparable<T>> {
    void call(T datum, Object params);
}

class Cliente implements Comparable<Cliente> {

    private String numero_de_cuenta;
    private String nombre;
    private float balance;

    @Override
    public boolean equals(Object cliente) {
        return this==cliente || (cliente instanceof Cliente && numero_de_cuenta.equals(((Cliente)cliente).numero_de_cuenta));
    }

    @Override
    public int compareTo(Cliente cliente) {
        return numero_de_cuenta.compareTo(cliente.numero_de_cuenta);
    }

    @Override
    public String toString() {
        return
            "numero de cuenta: " + numero_de_cuenta + "\n" +
            "nombre          : " + nombre + "\n" +
            "balance         : " + balance + "\n";
    }

    public String getNumero_de_cuenta() {
        return numero_de_cuenta;
    }

    public void setNumero_de_cuenta(String numero_de_cuenta) {
        this.numero_de_cuenta = numero_de_cuenta;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public float getBalance() {
        return balance;
    }

    public void setBalance(float balance) {
        this.balance = balance;
    }
}

class BinaryTree<T extends Comparable<T>> {

    private BinaryTree<T> left;
    private BinaryTree<T> right;
    private T datum;

    private BinaryTree() {}

    private BinaryTree(T datum) {
        left = null;
        right = null;
        this.datum = datum;
    }

    public static <T extends Comparable<T>> BinaryTree<T> insert(BinaryTree<T> node, T datum) {
        if (node == null)
            node = new BinaryTree<T>(datum);
        else if (datum.compareTo(node.datum) < 0)
            node.left = insert(node.left, datum);
        else
            node.right = insert(node.right, datum);
        return node;
    }

    public static <T extends Comparable<T>> T search(BinaryTree<T> node, T datum) {
        return node != null ? (datum.equals(node.datum) ? node.datum : (datum.compareTo(node.datum) < 0 ?
            search(node.left, datum) : search(node.right, datum))) : null;
    }

    public static <T extends Comparable<T>> BinaryTree<T> remove(BinaryTree<T> node, T datum) {
        if (node != null) {
            if (node.datum == datum) {
                BinaryTree<T> pivot;
                if (node.left == null)
                    pivot = node.right;
                else if (node.right == null)
                    pivot = node.left;
                else {
                    for (pivot = node.left; pivot.right != null; pivot = pivot.right);
                    pivot.right = node.right;
                    pivot = node.left;
                }
                node.left = null;
                node.right = null;
                node = pivot;
            } else if (datum.compareTo(node.datum) < 0)
                node.left = remove(node.left, datum);
            else
                node.right = remove(node.right, datum);
        }
        return node;
    }

    public static <T extends Comparable<T>> void preorder(BinaryTree<T> node, ForEachFunction<T> func, Object params) {
        if (node != null) {
            func.call(node.datum, params);
            preorder(node.left, func, params);
            preorder(node.right, func, params);
        }
    }

    public static <T extends Comparable<T>> void inorder(BinaryTree<T> node, ForEachFunction<T> func, Object params) {
        if (node != null) {
            inorder(node.left, func, params);
            func.call(node.datum, params);
            inorder(node.right, func, params);
        }
    }

    public static <T extends Comparable<T>> void postorder(BinaryTree<T> node, ForEachFunction<T> func, Object params) {
        if (node != null) {
            postorder(node.left, func, params);
            postorder(node.right, func, params);
            func.call(node.datum, params);
        }
    }
}