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)