module AlgoritmosDF (cierreDF,
                     cierreAtrib,
                     clavesCandidatas) where

import TiposDF
import Data.Set
import Utils



-- cierreDF r f calcula el cierre del conjunto f de dependencias funcionales bajo el esquema de relación r (f+)
cierreDF :: Set Atrib -> Set DF -> Set DF
cierreDF r f =  recursivo r (Data.Set.foldr union f (Data.Set.map (\x -> reflexivo x) (powerSet' r)))

iter :: Set Atrib -> Set DF -> Set DF
iter r f = transitividad $ aumentatividad r f

recursivo :: Set Atrib -> Set DF -> Set DF
recursivo r f = let res = iter r f in
                       if (Data.Set.size res /= (Data.Set.size f)) then recursivo r res
                       else res

r = fromList ["a","b","c"]
f = fromList[(fromList["a"],fromList["c"]),(fromList["c"],fromList["b"])]

reflexivo :: Set Atrib -> Set DF
reflexivo r =   Data.Set.foldr union empty (Data.Set.map (\x -> insert (r , x) empty) (powerSet' r))

aumentatividad :: Set Atrib -> Set DF -> Set DF
aumentatividad r f = Data.Set.foldr union  f (Data.Set.map (\f1 -> aum' r f1) f)

aum' :: Set Atrib -> DF -> Set DF
aum' r (a,b) = Data.Set.map (\x -> ((insert x a),(insert x b))) r

transitividad :: Set DF -> Set DF
transitividad f = Data.Set.foldr union f (Data.Set.map (\f1 -> trans' f1 f) f)



trans' :: DF -> Set DF -> Set DF
trans' f1 f =  Data.Set.map (\f2 -> trans'' f1 f2) f

trans'' :: DF -> DF -> DF
trans'' (a,b) (c,d) = if (b==c) then (a,d) else if (a==d) then (c,b) else (a,b)

-- cierreAtrib a f calcula el cierre del conjunto de atributos a bajo el conjunto f de dependencias funcionales
cierreAtrib :: Set Atrib -> Set DF -> Set Atrib
cierreAtrib r f = recursivo' r f

recursivo' :: Set Atrib -> Set DF -> Set Atrib
recursivo' r f = let res = iter' r f in
                       if (Data.Set.size res /= (Data.Set.size r)) then recursivo' res f
                       else res

iter' :: Set Atrib -> Set DF -> Set Atrib
iter' r f = Data.Set.foldr union r (Data.Set.map (\(b,c) -> if (Data.Set.isSubsetOf b r) then c else empty) f)

-- clavesCandidatas r f calcula el conjunto de todas las claves candidatas para el esquema de relación r con dependencias funcionales f
clavesCandidatas :: Set Atrib -> Set DF -> Set (Set Atrib)
clavesCandidatas = undefined

result r f = let m = Data.Set.findMin (longs r f) in Data.Set.filter (\(s,x) -> if s==m then True else False) (longsx r f)

longsx r f = Data.Set.map (\x -> let cA = Data.Set.size (cierreAtrib x f) in if cA == Data.Set.size r then
  (Data.Set.size x, x) else (Data.Set.size r,r)) (powerSet' r)

longs r f = Data.Set.map (\x -> let cA = Data.Set.size (cierreAtrib x f) in if cA == Data.Set.size r then
    Data.Set.size x else Data.Set.size r) (powerSet' r)
p a b = putStrLn $ showTreeWith True False $ cierreDF a b

a = fromList ["a", "b", "c", "d", "e","f","g","h","i","j"]
b = fromList [(fromList["a","b"], fromList["c"]), (fromList["b","d"], fromList["e","f"]), (fromList["a","d"], fromList["g","h"]), (fromList["a"], fromList["i"]), (fromList["h"], fromList["j"])]


--I ->