using System;

using System.Collections.Generic;

​

// Se supone que nos van a devoler una cantidad de plata menor o igual a la que

// prestemos. Entonces en todo momento, sumar la cantidad de plata prestada tiene

// que ser mayor igual a las devoluciones.

// Pero no estamos controlando a quien persona se le presta cuanto ni nada (el 

// enunciado no lo pide), asi que solo tenemos valores sueltos de prestamos y

// devoluciones.

// Si cuando queremos agregar una devolucion o usar el SetDevoluciones, pasa a

// haber mas devoluciones que prestamos, entonces lanzamos excepcion.

// Podriamos hacer "throw new Exception()" y va a lanzar una excepcion común,

// pero en el naval veiamos que estaba bueno tener como excepciones creadas por

// vos para manejar tus casos particulares. Asi que creamos una para este caso.

// El codigo lo copie de una pagina porque no me acordaba como eran.

public class DevolucionSinPrestamoException : System.Exception

{

    double total_prestado;

    double total_devuelto;

    public DevolucionSinPrestamoException() : base() { }

    public DevolucionSinPrestamoException(double total_prestado, double total_devuelto) : base()

    {

        this.total_prestado = total_prestado;

        this.total_devuelto = total_devuelto;

    }

​

    // El metodo ToString se usa como convencion para escribir por cosas.

    // Por Ejemplo podriamos hacer 

    // // Console.WriteLine("Error: Hay mas dinero devuelto ($ " + total_devuelto + ") que prestado ($ " + total_prestado + ").");

    // o meter "Error: Hay mas dinero devuelto ($ " + total_devuelto + ") que prestado ($ " + total_prestado + ")."

    // como respuesta del metodo ToString y despues solamente hacer

    // // DevolucionSinPrestamoException a = new DevolucionSinPrestamoException(100.0, 100.0);

    // // Console.WriteLine(a);

    public override string ToString()

    {

        return "Error: Hay mas dinero devuelto ($ " + total_devuelto + ") que prestado ($ " + total_prestado + ").\n";

    }

}

​

public class Libro

{

    // Propiedades

    private List<double> prestamos;

    private List<double> devoluciones;

    private double total_prestado;

    private double total_devuelto;

    // Constructores

    // Queremos que todas las instancias que se crean de Libro sean

    // validas. Por lo que no deberia pasar que la cantidad devuelta

    // sea mayor a la cantidad prestad. Vamos a ir chequeando que

    // esto valga para cada uno.

    // Default

    public Libro()

    {

        // En el constructor default todo vale 0 y vale 

        // total_prestado >= total_devuelto

        prestamos = new List<double>();

        devoluciones = new List<double>();

        total_prestado = 0.0;

        total_devuelto = 0.0;

    }

​

    // Esto lo vamos a usar para nosotros en el proximo constructor

    private double SumarLista(List<double> valores)

    {

        // Inicializamos una variable de tipo double que son los 

        // numeros con coma y vamos a pasar por todas los numeros

        // en valores e ir sumandolos en esta variable.

        // valores es una lista de numeros de tipo double.

        double total = 0.0;

        for (int i = 0; i < valores.Count; i++)

        {

            total = total + valores[i];

        }

        return total;

    }

​

    // Con parametros

    public Libro(List<double> prestamos, List<double> devoluciones)

    {

        // En este caso, nada nos dice que valga

        // total_prestado >= total_devuelto

        // Asi que tenemos que chequearlo nosotros

        this.prestamos = new List<double>(prestamos);

        total_prestado = SumarLista(GetPrestamos());

        this.devoluciones = new List<double>(devoluciones);

        total_devuelto = SumarLista(GetDevoluciones());

​

        if (total_prestado < total_devuelto)

        {

            throw new DevolucionSinPrestamoException(total_prestado, total_devuelto);

        }

    }

​

    // Por copia

    public Libro(Libro libro)

    {

        // Si nos aseguramos que de ninguna forma dejamos que una instancia de Libro

        // una vez creada se invalide, y aparte vemos que no se pueden crear instancias

        // invalidas, podriamos que el Libro que viene por parametros de este constructor

        // es valido y cumple 

        // total_prestado >= total_devuelto

        //

        // Pero como podriamos tener un error en otro lado, no esta de mas chequear que valga.

        double total_prestado_aux = SumarLista(libro.GetPrestamos());

        double total_devuelto_aux = SumarLista(libro.GetDevoluciones());

        if (total_prestado_aux < total_devuelto_aux)

        {

            throw new DevolucionSinPrestamoException(total_prestado_aux, total_devuelto_aux);

        }

        this.prestamos = new List<double>(libro.GetPrestamos());

        this.devoluciones = new List<double>(libro.GetDevoluciones());      

        total_devuelto = total_devuelto_aux;

        total_prestado = total_prestado_aux;

    }

    //Getters y Setters por cada propiedad

    public List<double> GetPrestamos()

    {

        // Devolvemos una copia de los prestamos para que quien reciba esto no

        // pueda modificar la lista y dejar una instancia de Libro donde no

        // vale:

        // // total_prestado >= total_devuelto

        //

        // o que total_prestado sea diferente a la suma de los valores en prestamos.

        //

        // En especial aca podrian borrar cosas en la lista hasta que la suma sea menor.

        // Pero con borrar uno ya total_prestado va a tener un valor distinto.

        return new List<double>(prestamos);

    }

    public void SetPrestamos(List<double> prestamos)

    {

        // De nuevo como antes hay que chequear que la suma de los prestamos

        // sea mayor a la suma de las devoluciones

        double total_prestado_aux = SumarLista(prestamos);

        if (total_prestado_aux < total_devuelto)

        {

            throw new DevolucionSinPrestamoException(total_prestado_aux, total_devuelto);

        }

​

        this.prestamos = new List<double>(prestamos);

        total_prestado = total_prestado_aux;

    }

    public List<double> GetDevoluciones()

    {

        // Lo mismo que sucede con los prestamos

        return new List<double>(devoluciones);

    }

    public void SetDevoluciones(List<double> devoluciones)

    {

        double total_devuelto_aux = SumarLista(devoluciones);

        if (total_prestado < total_devuelto_aux)

        {

            // Hay mas devoluciones que prestamos, y no tiene sentido, por lo que estamos

            // en un error. Podriamos crear una Excepcion especial para este tipo.

            throw new DevolucionSinPrestamoException(total_prestado, total_devuelto_aux);

        }

​

        this.devoluciones = new List<double>(devoluciones);

        total_devuelto = total_devuelto_aux;

    }

    // Otros metodos que pide el ejercicio

    public void HacerPrestamo(double monto_a_prestar)

    {

        // En este caso la cantidad prestada a lo sumo crece,

        // asi que si valia antes que 

        // total_prestado >= total_devuelto

        // va a seguir valiendo

        prestamos.Add(monto_a_prestar);

        total_prestado += monto_a_prestar;

    }

    public void HacerDevolucion(double monto_a_devolver)

    {

        // En este caso podria dejar de valer 

        // total_prestado >= total_devuelto

        if (total_prestado < total_devuelto + monto_a_devolver)

        {

            throw new DevolucionSinPrestamoException(total_prestado, total_devuelto + monto_a_devolver);

        }

        devoluciones.Add(monto_a_devolver);

        total_devuelto = total_devuelto + monto_a_devolver;

    }

    public override string ToString()

    {

        string texto = "Total prestado: " + total_prestado + ". Total devuelto: " + total_devuelto + " \n";

        texto += "Prestamos : [";

        for (int i = 0; i < prestamos.Count; i++)

        {

            texto += " " + prestamos[i] + " ";

        }

        texto += "]\n";

        texto += "Devoluciones : [";

        for (int i = 0; i < devoluciones.Count; i++)

        {

            texto += " " + devoluciones[i] + " ";

        }

        texto += "]\n";

        return texto;

    }

}

​

public class Program

{

    public static void Main()

    {

        // Creamos 3 cuentas, una con cada metodo

        Libro libro1 = new Libro();

        // Ambas dos lineas siguientes son equivalentes

        Console.WriteLine("Libro 1 (ToString)");

        Console.WriteLine(libro1.ToString());

        Console.WriteLine(libro1);

        // porque cuando pasamos una variable se fija si tiene el ToString y llama a eso

        // No podemos crear una instancia de Libro con mas devoluciones que prestamos

        List<double> devoluciones_altas = new List<double> {10000.0, 5000.0, 75000.5};

        List<double> prestamos_bajos = new List<double> {3.0};  

        try {

            Libro libro_invalido = new Libro(prestamos_bajos, devoluciones_altas);

        }

        catch (DevolucionSinPrestamoException e)

        {

            Console.WriteLine(e); // Como tiene un ToString definido podemos mandarlo directo a WriteLine

        }

        Console.WriteLine();

        List<double> devoluciones = new List<double> {100.0, 50.0, 75.5};

        List<double> prestamos = new List<double> {300.0, 250.0, 150.0};

        Libro libro2 = new Libro(prestamos, devoluciones);

        Libro libro3 = new Libro(libro2);

        // Ambos libros deberian escribir lo mismo

        Console.WriteLine("Libro 2 (ToString)");

        Console.WriteLine(libro2);

        Console.WriteLine("Libro 3 (ToString)");

        Console.WriteLine(libro3);

        // Agregamos ahora algunos prestamos y transferencias

        libro1.HacerPrestamo(1000.0);

        libro2.HacerDevolucion(440.0);

        Console.WriteLine("Libro 1 (ToString)");

        Console.WriteLine(libro1);

        Console.WriteLine("Libro 2 (ToString)");

        Console.WriteLine(libro2);

        Console.WriteLine("Libro 3 (ToString)");

        Console.WriteLine(libro3);

        // Hacemos, Get, modificamos la lista pero no deberia modificarse la instancia Libro porque es una

        // copia de la lista y no una referencia.

        List<double> prestamosLibro1 = libro1.GetPrestamos();

        Console.Write("Prestamos libro 1: ");

        for(int i = 0; i < prestamosLibro1.Count; i++)

        {

            Console.Write( prestamosLibro1[i] + " " );

        }

        Console.WriteLine();

        Console.WriteLine();

        prestamosLibro1.Add(45.0);

        Console.Write("Nuevos prestamos libro 1: ");

        for(int i = 0; i < prestamosLibro1.Count; i++)

        {

            Console.Write( prestamosLibro1[i] + " " );

        }

        Console.WriteLine();

        Console.WriteLine();

        Console.WriteLine(libro1);

        // Ahora si se la seteamos si deberia imprimirlo por pantalla

        libro1.SetPrestamos(prestamosLibro1);

        Console.WriteLine(libro1);

        // Por ultimo si al setear devoluciones o prestamos deja de valor 

        // total_prestado >= total_devuelto

        try {

            libro2.SetPrestamos(prestamos_bajos);

        }

        catch (DevolucionSinPrestamoException e)

        {

            Console.WriteLine(e); // Como tiene un ToString definido podemos mandarlo directo a WriteLine

        }

        try {

            libro1.SetDevoluciones(devoluciones_altas);

        }

        catch (DevolucionSinPrestamoException e)

        {

            Console.WriteLine(e); // Como tiene un ToString definido podemos mandarlo directo a WriteLine

        }

    }

}