# encoding: utf-8
# Este módulo se ha creado para la asignatura Lenguajes y Paradigmas de la Programación
# para aprender a utilizar las diferentes herramientas de las que dispone Ruby.
# Contiene las clases Alimento, GrupoAlimento, Nodo y Lista.
#
# Author::    Mireia Scholz  (alu0100905144@ull.edu.es)
# Copyright:: Cretive Commons
# License::   Distributes under the same terms as Ruby

module Alimento
    
    # Esta clase permite representar un alimento y calcular su valor energético.
    class Alimento
        
        include Comparable
        attr_reader :nombre, :proteinas, :glucidos, :lipidos, :data
        
        #Se asignan el nombre y los valores gramos de proteínas, glúcidos y lípidos al alimento.
        def initialize(nombre, proteinas, glucidos, lipidos, data)
            @nombre = nombre
            @proteinas = proteinas
            @glucidos = glucidos
            @lipidos = lipidos
            @data = data
        end
        
        #Permite visualizar el alimento formateado.
        def to_s
            return %Q(#{@nombre.capitalize}: #{@proteinas}gr de proteínas, #{@glucidos}gr de hidratos de carbono y #{@lipidos}g de grasas)
        end
        
        #Calcula el valor energético del alimento a partir de los gramos de proteínas, glúcidos y lípidos.
        def valor_energetico 
            (@proteinas * 4 + @glucidos * 4 + @lipidos * 9)
        end
        
        # Se define para incluir el mixin comparable. 
        # Se toma como valor para la comparación el nombre del alimento.
        def <=>(other)
          return nil unless other.kind_of?Alimento
          valor_energetico <=> other.valor_energetico
        end
        
        # Calcula el área incremental bajo la curva del
        # del vector de datos del alimento y de la glucosa. 
        # Necesario para calcular el IG del alimento
        def aibc (g)
            r = g.map do |i| 
                i.each_with_index.map do |j, it| 
                    if it > 0 
                      0.0 if (i[it] < i[0])
                      (((i[it] - i[0]) + (i[it-1] - i[0])) / 2)*5 if (i[it] >= i[0])
                      
                        
                    end
                end
            end
            
            s = r.map{ |i| i.reject{ |gij| gij.class == nil::NilClass}}
            s.map{ |i| i.reduce(0, :+) }
            
        end
        
        # Calcula el indicie glucémico asociado a un único individuo. 
        # Necesario para calcular el IG del alimento
        def ig_ind(g)
            (aibc(g)).reduce(:/) * 100
        end
        
        # Devuelve el índice glucémico del alimento para los datos que se le
        # pasaron al objeto cuando fue instanciado.
        def ig
          (data.map{ |i| ig_ind(i)}.reduce(:+))/data.size
        end
        
    end
    
    #Extensión de la clase Alimento. 
    #Cuenta con una variable grupo (por ejemplo Lácteo, Carne, etc).
    class GrupoAlimento < Alimento
       attr_reader :grupo
       
       #Asigna el grupo e invoca el método del mismo nombre del padre con los demás valores.
        def initialize(grupo, nombre, proteinas, glucidos, lipidos, data)
            super(nombre, proteinas, glucidos, lipidos, data)
            @grupo = grupo
        end
        
        #Muestra el alimento formateado pero mostrando también el grupo.
        def to_s
            s = "#{@grupo}"
            s << ": "
            s << super.to_s #encadenamiento
            return s    
        end
    end
end