#!/usr/bin/env python
#-*- coding: iso8859-15 -*-
##########################################################
#         FUNCIONES DE CONTROL DE FECHAS v1.0            #
##########################################################
# Autor: Juan Miguel Taboada Godoy                       #
# Fecha: Malaga, 16 de noviembre de 2006                 #
# Descripción: Contiene todos las funciones para el      #
# control y manejo de fechas                             #
# Versión: 2006111600                                    #
#                                                        #
# Codigo fuente bajo licencia GNU/GPL                    #
# Centrologic (Computational Logistic Center)            #
# http://www.centrologic.com - info@centrologic.com      #
##########################################################

## \defgroup DATE DATE: Libreria para control de fechas
## \version 16/11/2006 1449 Szczecin

# Librerías necesarias {{{1
import time
import datetime
import string
from MATH_GRA import digitos
# }}}1

# Dada una fecha en formato dd/mm/aa hh:mm:ss, la transforma a fecha TIMENORMAL {{{1
## \ingroup DATE
## \internal
## Dada una fecha en formato "dd/mm/aa hh:mm:ss", la transforma a fecha TIMENORMAL
## \param [in] fecha Formato de entrada: "14/10/05 19:13:32"
## \return Formato de salida: "05-10-14 19:13:32"
def timenormal(fecha):
	# Recorto la fecha
	lista=[]
	cad=''
	for caracter in fecha:
		if (caracter=='/') or (caracter==' ') or (caracter==':'):
			lista.append(cad)
			cad=''
		elif (caracter=='\n') or (caracter=='\r'):
			cad=cad
		else:
			cad=cad+caracter
	lista.append(cad)
	cad=''
	# Separo las variables
	dia=digitos(lista[0],2)
	mes=digitos(lista[1],2)
	anyo=digitos(lista[2],4)
	hora=digitos(lista[3],2)
	minuto=digitos(lista[4],2)
	segundo=digitos(lista[5],2)
	# Creo la fecha
	timenormal=anyo+"-"+mes+"-"+dia+" "+hora+":"+minuto+":"+segundo
	# Devuelvo el resultado
	return timenormal
#}}}1
# Dada una fecha en formato "dd/mm/aa hh:mm:ss", la transforma a fecha TIMESTAMP {{{1
## \ingroup DATE
## \internal
## Dada una fecha en formato "dd/mm/aa hh:mm:ss", la transforma a fecha TIMESTAMP
## \param [in] fecha Formato de entrada: "14/10/05 19:13:32"
## \return Formato de salida: "051014191332"
def timestamp(fecha):
	# Recorto la fecha
	lista=[]
	cad=''
	for caracter in fecha:
		if (caracter=='/') or (caracter==' ') or (caracter==':'):
			lista.append(cad)
			cad=''
		elif (caracter=='\n') or (caracter=='\r'):
			cad=cad
		else:
			cad=cad+caracter
	lista.append(cad)
	cad=''
	# Separo las variables
	dia=lista[0]
	mes=lista[1]
	anyo=lista[2]
	hora=lista[3]
	minuto=lista[4]
	segundo=lista[5]
	# Creo la fecha
	timestamp=anyo+mes+dia+hora+minuto+segundo
	# Devuelvo el resultado
	return int(timestamp)
#}}}1
# Dada una fecha en formato dd/mm/aa hh:mm:ss, la transforma a fecha EPOCH {{{1
## \ingroup DATE
## \internal
## Dada una fecha en formato "dd/mm/aa hh:mm:ss", la transforma a fecha EPOCH
## \param [in] fecha Formato de entrada: "14/10/05 19:13:32"
## \return Formato de salida: "1023456427"
def timeepoch(fecha):
	# Recorto la fecha
	lista=[]
	cad=''
	for caracter in fecha:
		if (caracter=='/') or (caracter==' ') or (caracter==':'):
			lista.append(cad)
			cad=''
		elif (caracter=='\n') or (caracter=='\r'):
			cad=cad
		else:
			cad=cad+caracter
	lista.append(cad)
	cad=''
	# Separo las variables
	dia=string.atoi(lista[0])
	mes=string.atoi(lista[1])
	anyo=string.atoi(lista[2])
	hora=string.atoi(lista[3])
	minuto=string.atoi(lista[4])
	segundo=string.atoi(lista[5])
	# Creo la fecha
	fecha = datetime.datetime(anyo,mes,dia,hora,minuto,segundo)
	# Transformo la fecha a EPOCH
	epoch = time.mktime(fecha.timetuple()) 
	# Devuelvo el resultado
	return int(epoch)
#}}}1
# Dada una fecha en formato "aaaa-mm-dd" + "hh:mm:ss", la transforma a fecha EPOCH {{{1
## \ingroup DATE
## \internal
## Dada una fecha en formato "dd/mm/aa hh:mm:ss", la transforma a fecha EPOCH
## \param [in] fecha Formato de la fecha de entrada: "2005-10-14"
## \param [in] hora Formato de la hora de entrada"19:13:32"
## \return Formato de salida: "1023456427"
def dateepoch(fecha,hora):
	# Extraigo la hora
	fecha=fecha.split("-")
	anyo=fecha[0]
	mes=fecha[1]
	dia=fecha[2]
	# Extraigo la hora
	thora=hora.split(":")
	hora=thora[0]
	minuto=thora[1]
	segundo=thora[2]
	# Creo la nueva fecha$
	nfecha=datetime.datetime(int(anyo),int(mes),int(dia),int(hora),int(minuto),int(segundo))
	# Transformo la fecha a EPOCH
	epoch=time.mktime(nfecha.timetuple())
	# Devuelvo el resultado
	return epoch
#}}}1
# Dada una fecha en formato EPOCH, la transforma a "aaaa-mm-dd" + "hh:mm:ss" {{{1
## \ingroup DATE
## \internal
## Dada una fecha en formato EPOCH, la transforma a "aaaa-mm-dd" + "hh:mm:ss"
## \param [in] timestamp Formato de la entrada: "1023456427"
## \retval (fecha,hora) con formato de salida: ("2005-10-14","19:13:32")
def epochdate(timestamp):
	fechahora=datetime.datetime.fromtimestamp(float(timestamp))
	fechatuple=fechahora.timetuple()
	fecha="%s-%s-%s" % (fechatuple[0],digitos("%s" % fechatuple[1],2),digitos("%s" % fechatuple[2],2))
	hora="%s:%s:%s" % (digitos("%s" % fechatuple[3],2),digitos("%s" % fechatuple[4],2),digitos("%s" % fechatuple[5],2))
	return (fecha,hora)
# }}}1
# Función para comparar fechas/horas {{{1
## \ingroup DATE
## \internal
## Compara fechas/horas con otras fechas/horas
## \param [in] fechaA Formato de la fecha de entrada A: "2006-10-14"
## \param [in] horaA Formato de la hora de entrada A: "22:48:57"
## \param [in] fechaB Formato de la fecha de entrada B: "2006-10-13"
## \param [in] horaB Formato de la hora de entrada B: "23:42:21"
## \return -1 si fechahoraA<fechahoraB \n 0 si fechahoraA=fechahoraB \n +1 si fechahoraA>fechahoraB
def datestrcmp(fechaA,horaA,fechaB,horaB):
	fechaA2=fechaA.split("-")
	horaA2=horaA.split(":")
	fechaB2=fechaB.split("-")
	horaB2=horaB.split(":")
	fechaA=(int(fechaA2[0]),int(fechaA2[1]),int(fechaA2[2]))
	horaA=(int(horaA2[0]),int(horaA2[1]),int(horaA2[2]))
	fechaB=(int(fechaB2[0]),int(fechaB2[1]),int(fechaB2[2]))
	horaB=(int(horaB2[0]),int(horaB2[1]),int(horaB2[2]))
	if (fechaA==fechaB):
		if (horaA==horaB):
			return 0
		elif (horaA<horaB):
			return -1
		else:
			return 1
	elif (fechaA<fechaB):
		return -1
	else:
		return 1
# }}}1
# Funciones de conteo de tiempo para la descarga {{{1
## \ingroup DATE
## \internal
## Genera los checkpoints temporales para la actualizacion de informacion
## \param [in] fecha Es la fecha del primer checkpoint, con formato timetuple de Python: (2006, 11, 20, 15, 17, 32, 0, 324, -1)
## \param [in] token Cada cuanto tiempo se genera un nuevo checkpoint
## \return Devuelve el siguiente checkpoint
def tempo_limit(fecha,token):
	# Creo el primer momento del año en formato epoch
	fecha_ini=datetime.datetime(fecha[0],1,1,0,0,0)
	epoch_ini=int(time.mktime(fecha_ini.timetuple()))
	# Obtengo el format epoch de a fecha actual
	epoch_now=int(time.mktime(fecha))
	# Encuentro la diferencia
	diferencia=epoch_now-epoch_ini
	# Divido para encontrar el cociente
	cociente=diferencia/token
	# Sumo al epoch_ini los token necesarios hasta llegar el checkpoint que busco
	checkpoint=epoch_ini+cociente*token
	# Devuelvo la fecha checkpoint en formato epoch
	return checkpoint
# }}}1
# Calculador temporalidad {{{1
## \ingroup DATE
## Dada una cadena, indica cuantos segundos corresponden
## \param [in] valor Puede ser: "dias","meses","segundos", "minutos", "horas", "dias", numero segundos
## \return Devuelve el numero de segundos que contiene el texto dado
def coste_temporal(valor):
	if (type(valor)==type(1)):
		return valor
	else:
		if ((valor=="segundos") or (valor=="seconds")):
			# Segundos
			return 1
		elif ((valor=="minutos") or (valor=="minuts")):
			# Minutos
			return 60
		elif ((valor=="horas") or (valor=="hours")):
			# Horas
			return 3600
		elif ((valor=="dias") or (valor=="days")):
			# Dias
			return 3600*24
		elif ((valor=="semanas") or (valor=="weeks")):
			# Dias
			return 3600*24*7
		elif ((valor=="meses") or (valor=="months")):
			# Meses
			return 3600*24*30
		elif ((valor=="anyos") or (valor=="years")):
			# Meses
			return 3600*24*365
		else:
			# Por defecto devolver horas
			return 3600
# }}}1
# Devuelve un valor temporal formateado {{{1
## \ingroup DATE
## \internal
## Convierte una fecha a un formato mas legible
## \param [in] segundos Numero de segundos a computar
## \param [in] formatear_segundos Reduce el numero de digitos de los segundos (para no mostrar muchos decimales)
## \return Devuelve un texto con la fecha formateada
def tiempo_str(segundos,formatear_segundos=False):
	# Número de días
	dias=int(segundos/(3600*24))
	segundos=segundos%(3600*24)
	# Número de horas
	horas=int(segundos/(3600))
	segundos=segundos%(3600)
	# Número de minutos
	minutos=int(segundos/(60))
	# Número de segundos
	segundos=segundos%(60)
	
	# Inicializo valores
	cadena=""
	hueco=""
	# Genero la cadena
	if (dias>0):
		# Días
		cadena="%s%s%s dias" % (cadena,hueco,dias)
		hueco=","
	if (horas>0):
		# Horas
		cadena="%s%s%s horas" % (cadena,hueco,horas)
		hueco=","
	if (minutos>0):
		# Minutos
		cadena="%s%s%s minutos" % (cadena,hueco,minutos)
		hueco=","
	if (segundos>0):
		# Segundos
		if (formatear_segundos):
			segundos=segundos-((segundos*100)-(int(segundos*100)))/100
		cadena="%s%s%s segundos" % (cadena,hueco,segundos)
	return cadena
# }}}1
# Devuelve el siguiente dia de la semana {{{1
## \ingroup DATE
## \internal
## Indica la letra del siguiente dia de la semana
## \param [in] letra Letra de la semanandos a computar (no importa mayusculas o minusculas)
## \return Devuelve la letra (mayuscula) del siguiente dia de la semana en una tupla que contiene: (nuevo_dia,dia_entregado). Ejemplo: ("L","D")
def siguientediasemana(letra):
	aini=letra
	if ((aini=='L') or (aini=="l")):
		dia="L"
		new="M"
	elif ((aini=='M') or (aini=="m")):
		dia="M"
		new="X"
	elif ((aini=='X') or (aini=="x")):
		dia="X"
		new="J"
	elif ((aini=='J') or (aini=="j")):
		dia="J"
		new="V"
	elif ((aini=='V') or (aini=="v")):
		dia="V"
		new="S"
	elif ((aini=='S') or (aini=="s")):
		dia="S"
		new="D"
	elif ((aini=='D') or (aini=="d")):
		dia="D"
		new="L"
	# Devuelvo la tupla
	return (new,dia)
# }}}1