# -*- coding: utf-8 -*-
# Author: Julien Moutinho <julm@autogeree.net>
# License: GNU GPLv3 (or later, at your choice)

from __future__ import unicode_literals
import uno
from com.sun.star.awt.MessageBoxType    import MESSAGEBOX, INFOBOX, WARNINGBOX, ERRORBOX, QUERYBOX
from com.sun.star.awt.MessageBoxButtons import BUTTONS_OK, BUTTONS_OK_CANCEL, BUTTONS_YES_NO, BUTTONS_YES_NO_CANCEL, BUTTONS_RETRY_CANCEL, BUTTONS_ABORT_IGNORE_RETRY
from com.sun.star.awt.MessageBoxResults import OK, YES, NO, CANCEL
from com.sun.star.beans import PropertyValue
from com.sun.star.sheet import CellFlags

if 'XSCRIPTCONTEXT' in globals():
	def getModel():
		return (XSCRIPTCONTEXT.getDocument(), XSCRIPTCONTEXT)
	def debug(msg):
		return
else:
	from connect_to_libre_office import getModel
	def debug(msg):
		print(msg)

def MakeDraw(*args):
	return

def nCk(n,k):
	"""
	nCk(n,k) retourne le nombre de combinaisons
	de longueur k d’un ensemble de longueur n.
	"""
	if n<0 or k<0 or n<k:
		raise ZeroDivisionError
	if k > n // 2:
		k = n - k # more efficient and safe with smaller numbers
	c = 1
	for j in range(1,k+1):
		c = c * (n-j+1) // j
	return c
def combinOfRank(n,k,rank):
	"""
	combinOfRank(n, k, r) retourne les indices de permutation
	de la combinaison de k entiers parmi [1..n]
	au rang lexicographique r dans [0 .. nCk(n,k)-1].
	
	Construit chaque choix de la combinaison en prenant le prochain plus grand
	dont le successeur engendre un nombre de combinaisons
	qui dépasse le rang restant à atteindre.
	
	DOC: <http://www.site.uottawa.ca/~lucia/courses/5165-09/GenCombObj.pdf>, p.26
	"""
	if rank<0 or nCk(n,k)<rank:
		raise ZeroDivisionError
	i = 1
	j = 1
	c = []
	while True: # for1K
		if i < k:
			while True: # uptoRank
				nbCombins = nCk(n-j, k-i)
				if nbCombins > rank:
					c.append(j)
					i += 1
					j += 1
					break
				else:
					j += 1
					rank -= nbCombins
		elif i == k:
			c.append(j+rank) # because when i == k, nbCombins is always 1
			break
		else:
			break
	return c
def rankOfCombin(n,ns):
	"""
	rankOfCombin(n, ns) retourne le rang lexicographique dans [0 .. nCk(n, length ns)-1]
	de la combinaison ns d’entiers parmi [1..n].
	
	WARNING: ns doit être triée de manière ascendante.
	
	Compte le nombre de combinaisons précédant celle de rang r.
	
	DOC: <http://www.site.uottawa.ca/~lucia/courses/5165-09/GenCombObj.pdf>, pp.24-25
	
	rankOfCombin(n, combinOfRank(n, k, r)) == r
	combinOfRank(n, len(ns), rankOfCombin(n, ns)) == ns
	"""
	if not all(1<=x or x<=n for x in ns):
		raise ZeroDivisionError
	k = len(ns)
	if n<k:
		raise ZeroDivisionError
	i = 1
	rank = 0
	x1 = 0
	for x in ns:
		for j in range(x1+1,x-1 +1):
			rank += nCk(n-j, k-i)
		i += 1
		x1 = x
	return rank

def nbBits(n):
	"""
	nbBits(n) retourne le nombre de bits servant à encoder n.
	"""
	if n<0:
		raise ZeroDivisionError
	r = 0
	while n > 0:
		r += 1
		n //= 2
	return r
def equiprobableBits(n):
	"""
	equiprobableBits(n) retourne le nombre maximal de bits de i
	équiprobables quand i parcourt [0 .. n-1].
	
	Ce nombre est le plus grand 'b' dans [0 .. ] tel que 2**b-1 <= n.
	
	map(equiprobableBits, range(0, 17+1)) == [0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,4,4,4]
	"""
	b = nbBits(n)
	return (b if n == 2**b-1 else b-1)
def bitsOfInteger(m, n):
	"""
	bitsOfInteger(m, n) retourne les m premiers bits de poids faible
	encodant le nombre n.
	"""
	if not(0<=m and 0<=n):
		raise ZeroDivisionError
	bs = []
	while m > 0:
		(q,r) = (n//2, n%2)
		bs.append(r==1)
		m -= 1
		n = q
	return bs
def randomOfCombin(n, k, ns):
	"""
	randomOfCombin(n, k, ns) retourne des bits équiprobables donnés
	par la combinaison ns obtenue par tirage équiprobable
	d’une combinaison de k entiers parmi [1 .. n].
	
	WARNING: aucun bit n’est extrait du tirage ns
	dans le cas où ns a un rang lexicographique encodé par
	un nombre de bits strictement supérieur à equiprobableBits(nCk(n, k)).
	"""
	if not(0<=n and 0<=k and k<=n and all(1<=x and x<=n for x in ns)):
		raise ZeroDivisionError
	ns.sort()
	rank = rankOfCombin(n, ns)
	epBits = equiprobableBits(nCk(n,k))
	return bitsOfInteger(epBits, rank) \
		if nbBits(rank) <= epBits else []

def randomOfFrenchLoto (n1,n2,n3,n4,n5, nc):
	"""
	randomOfFrenchLoto(n1,n2,n3,n4,n5, numComplementaire) retourne les bits équiprobables donnés
	par un tirage du Lo to Français : https://www.fdj.fr/jeux/jeux-de-tirage/loto/resultats/.
	
	Il peut produire @23@ bits équiprobables :
	sum(map(equiprobableBits, [nCk(49, 5), nCk(10, 1)]))
	
	randomOfFrenchLoto(1,2,3,4,5, 1)     == [False] * (20+3)
	randomOfFrenchLoto(7,27,36,40,46, 8) == [True]  * (20+3)
	
	combinOfRank(49, 5, 2 ** equiprobableBits(nCk(49,5)) - 1) == [7,27,36,40,46]
	combinOfRank(49, 5, 2 ** equiprobableBits(nCk(49,5)))     == [7,27,36,40,47]
	randomOfFrenchLoto(7,27,36,40,46, 1) == [True] * 20 + [False] * 3
	randomOfFrenchLoto(7,27,36,40,47, 1) == [False,False,False]
	
	combinOfRank(10, 1, 2 ** equiprobableBits(nCk(10, 1)) - 1) == [8]
	combinOfRank(10, 1, 2 ** equiprobableBits(nCk(10, 1)))     == [9]
	randomOfFrenchLoto(7,27,36,40,47, 8) == [True,True,True]
	randomOfFrenchLoto(7,27,36,40,47, 9) == []
	"""
	return \
		randomOfCombin(49, 5, [n1,n2,n3,n4,n5]) + \
		randomOfCombin(10, 1, [nc])
def randomOfEuroMillions(n1,n2,n3,n4,n5, nc1,nc2):
	"""
	https://www.fdj.fr/jeux/jeux-de-tirage/euromillions/resultats
	"""
	return \
		randomOfCombin(50, 5, [n1,n2,n3,n4,n5]) + \
		randomOfCombin(11, 2, [nc1,nc2])
def randomOfSwissLoto(n1,n2,n3,n4,n5,n6, nc):
	return \
		randomOfCombin(42, 6 [n1,n2,n3,n4,n5,n6]) + \
		randomOfCombin( 6, 1 [nc])
def randomOf6aus49(n1,n2,n3,n4,n5,n6, nc):
	return \
		randomOfCombin(49, 6, [n1,n2,n3,n4,n5,n6]) + \
		randomOfCombin(10, 1, [nc])

g_exportedScripts = MakeDraw,