module Teatro (nuevoT,
               salasT,
               funcionesT,
               elencoEstableT,
               sueldoT,
               nombrarArtistaT,
               eliminarArtistaT,
               programarFuncionT,
               venderEntradaT,
               costoDeUnaFuncionT,
               balanceT,
--               unaAlLadoDeLaOtraT,
               ) where
 			 
import Tipos
import Funcion
import Entrada
import Sala
import Fecha
import Hora

data Teatro = Tea [Sala] [Funcion] [Nombre] [Moneda] [Entrada] deriving (Eq)

instante Show Teatro 
        where show t = show (funcionesT t) ++ show (elencoEstableT t)

nuevoT :: [Sala] -> Teatro
nuevoT ss = Tea ss [] [] [] []

salasT :: Teatro -> [Sala]
salasT (Tea ss _ _ _ _) = ss

funcionesT :: Teatro -> [Funcion]
funcionesT (Tea _ fs _ _ _) = fs

elencoEstableT :: Teatro -> [Nombre]
elencoEstableT (Tea _ _ acts _ _) = acts

sueldoT :: Teatro -> Nombre -> Moneda
sueldoT (Tea _ _ acts ss _) nom | nom `elem` acts = ss !! (pos nom acts)

nombrarArtistaT :: Teatro -> Nombre -> Moneda -> Teatro
nombrarArtistaT (Tea sls fncs acts ss es) nom sue = Tea sls fncs (nom:acts) (sue:ss) es

eliminarArtistaT :: Teatro -> Nombre -> Teatro
aliminarArtistaT teatro@(Tea sls funs acts ss es) artista = (Tea sls func artistaQuitado sueldoQuitado es)
                              where artistaQuitado = (sacarElementoN (pos artista elencoT teatro) acts)
                                    sueldoQuitado = (sacarElementoN  (pos artista elencoT teatro) ss)

programarFuncionT :: Teatro -> Funcion -> Teatro
programarFuncionT (Tea sls fncs acts ss es) fun = Tea sls (fun:fncs) acts ss es

venderEntradaT :: Teatro -> Entrada -> Teatro
venderEntradaT (Tea sala funcion estable sueldo entradas) e = Tea sala funcion estable sueldo (e:entradas)
 
costoDeUnaFuncionT :: Teatro -> Funcion -> Moneda
costoDeUnaFuncionT t f = calcularCosto t f

balanceT :: Teatro -> Fecha -> Moneda
balanceT t f = sumaBalances t (funcionesHastaLaFecha t f)

----------------
-- Auxiliares --
----------------

pos :: Eq a => a -> [a] -> Int
pos a [] = error "La lista no puede estar vacia"
pos a xs | not(a `elem` xs)  = error "El elemento no esta en la lista"
pos a xs = auxPos a xs 0
 
auxPos :: Eq a => a -> [a] -> Int -> Int
auxPos a l i | a == l !! i = i
             | a /= l !! i = auxPos a l (i + 1) 


-- Devuelve una lista a la que se le saco el elemento de indice n
sacarElementoN :: Int -> [e] -> [e]
sacarElementoN n [] = error "La lista no puede estar vacia"
sacarElementoN n l | n >= length(l) = error "Debe indicar un indice valido"
                   | otherwise = auxSacarElementoN n l 0

auxSacarElementoN :: Int -> [e] -> Int -> [e]
auxSacarElementoN n l i | i == (length l) = l
auxSacarElementoN n (x:xs) c | c == n = xs
                             | otherwise = [x] ++ auxSacarElementoN n xs (c+1)

-- calcula el costo de una funcion
calcularCosto :: Teatro -> Funcion -> Moneda
calcularCosto t f = (sumarSueldosEstables t (elenco f)) + (sumarSueldosContratados f (contratadosF f))
 
sumarSueldosEstables :: Teatro -> [Nombre] -> Moneda
sumarSueldosEstables t [] = 0
sumarSueldosEstables t (x:[]) = (SueldoT t x) `div` 30
sumarSueldosEstables t (x:xs) = ((SueldoT t x) `div` 30) + (sumarSueldosEstables t xs)
 
sumarSueldosContratados :: Funcion -> [Nombre] -> Moneda
sumarSueldosContratados f [] = 0
sumarSueldosContratados f (x:[]) = cachetF f x
sumarSueldosContratados f (x:xs) = (cachetF f x) + (sumarSueldosContratados f xs)


-- devuelve la lista de funciones que tuvieron lugar hasta una cierta fecha
funcionesHastaLaFecha :: Teatro -> Fecha -> [Funcion]
funcionesHastaLaFecha t fec = auxFuncionesHastaLaFecha (FuncionesT t) fec

auxFuncionesHastaLaFecha :: [Funcion] -> Fecha -> [Funcion]
auxFuncionesHastaLaFecha [] _ = []
auxFuncionesHastaLaFecha (fu:funs) fec | (fechaF fu) <= fec = (fu:auxFuncionesHastaLaFecha funs)
                                       | otherwise = auxFuncionesHastaLaFecha funs

-- devuelve las entradas vendidas a una cierta funcion
entradasParaUnaFuncion :: Teatro -> Funcion -> [Entrada]
entradasParaUnaFuncion (Tea _ _ _ _ es) fun = auxEntradasParaUnaFuncion es fun

auxEntradasParaUnaFuncion :: [Entrada] -> Funcion -> [Entrada]
auxEntradasParaUnaFuncion [] fun = []
auxEntradasParaUnaFuncion (e:es) fun | esEntrada e fun = e:(auxEntradasParaUnaFuncion es fun)
                                     | otherwise = auxEntradasParaUnaFuncion es fun

esEntrada :: Entrada -> Funcion -> Bool
esEntrada e fun = (fechaE e == fechaF fun) &&
                  (horaE e == horaF fun) &&
                  (salaE e == salaF fun)

-- devuelve la recaudacion de una cierta funcion
recaudacionDeUnaFuncion :: Teatro -> Funcion -> Moneda
recaudacionDeUnaFuncion t f = auxRecaudacionDeUnaFuncion (entradasParaUnaFuncion t f) f

auxRecaudacionDeUnaFuncion :: [Entrada] -> Funcion -> Moneda
auxRecaudacionDeUnaFuncion [] _ = 0
auxRecaudacionDeUnaFuncion (e:es) fun = (preciosF fun) !! (sectorE e) +
                                        (auxRecaudacionDeUnaFuncion es fun)

-- devuelve el balance de una funcion
balanceDeUnaFuncion :: Teatro -> Funcion -> Moneda
balanceDeUnaFuncion t fun = (recaudacionDeUnaFuncion t fun) - (costoDeUnaFuncion t fun)

-- suma los balances de la lista de funciones que se proporciona
sumaBalances :: Teatro -> [Funcion] -> Moneda
sumaBalances t [] = 0
sumaBalances t (fu:funs) = (balanceDeUnaFuncion t fu) + (sumaBalances t funs)