module Dodge.Path 
    ( pointTowardsImpulse
    --, pointTowardsImpulse'
    , makePathBetween
    , makePathBetweenPs
    )
    where
import Dodge.Data
import Dodge.Base.Collide
import Dodge.Zone
import Geometry.Data

import Data.List
import Data.Maybe
--import Data.Graph.Inductive.PatriciaTree
import Data.Graph.Inductive.Query.SP
import Data.Graph.Inductive.Graph hiding ((&))

makePathBetween :: Point2 -> Point2 -> World -> Maybe [Int]
makePathBetween a b w = do -- join $ sp <$> a' <*> b' <*> return (_pathGraph w)
    na <- walkableNodeNear a
    nb <- walkableNodeNear b
    sp na nb (_pathGraph w)
  where
    nodesNear p = concat $ lookLookups (zoneAroundPoint p) (_pathPoints w)
    walkableNodeNear p = fmap fst . find (flip (isWalkable p) w . snd) $ nodesNear p

makePathBetweenPs :: Point2 -> Point2 -> World -> Maybe [Point2]
makePathBetweenPs a b w = mapMaybe (lab $ _pathGraph w) <$> makePathBetween b a w

pointTowardsImpulse :: Point2 -> Point2 -> World -> Maybe Point2
pointTowardsImpulse a b w = find (flip (isWalkable a) w) =<< makePathBetweenPs a b w

------ continues a walk from a list of points, without repetitions
------ supposes that the list is non-empty
--randomGraphWalk :: RandomGen g => [Int] -> Gr a b -> State g [Int]
--randomGraphWalk (n:ns) g = do 
--    next' <- randomGraphStepRestricted n ns g
--    case next' of 
--        Nothing -> return (n:ns)
--        Just n' -> randomGraphWalk (n':n:ns) g
--randomGraphWalk _ _ = error "Trying to walk in an empty list"
--
--randomPointXStepsFrom :: Int -> Point2 -> World -> Point2
--randomPointXStepsFrom i p w = 
--    let g  = _pathGraph w
--        ns = labNodes g
--        mp = listToMaybe $ sortBy (compare `on` dist p . snd) $ filter (flip (isWalkable p) w . snd) ns
--    in case mp of 
--        Nothing -> p
--        Just (n,_) -> fromJust 
--            $ lab g (last $ take i $ randomGraphWalk [n] g Data.Function.& evalState  $ _randGen w)
--
--randomPointsXStepsFrom :: Int -> Point2 -> World -> [Point2]
--randomPointsXStepsFrom i p w = 
--    let g  = _pathGraph w
--        ns = labNodes g
--        mp = listToMaybe $ sortBy (compare `on` dist p . snd) $ filter (flip (isWalkable p) w . snd) ns
--    in case mp of 
--        Nothing -> [p]
--        Just (n,_) -> mapMaybe (lab g) (take i $ randomGraphWalk [n] g Data.Function.& evalState $ _randGen w)
--
--randomGraphStep :: RandomGen g => Int -> Gr a b -> State g (Maybe Int)
--randomGraphStep n g = 
--    do let ns = neighbors g n
--       i  <- state $ randomR (0,length ns - 1)
--       case ns of [] -> return Nothing
--                  _  -> return $ Just $ ns !! i
--randomGraphStepRestricted :: RandomGen g => Int -> [Int] -> Gr a b -> State g (Maybe Int)
--randomGraphStepRestricted n notns g = do 
--    let ns = neighbors g n \\ notns
--    i  <- state $ randomR (0,length ns - 1)
--    case ns of 
--        [] -> return Nothing
--        _  -> return $ Just $ ns !! i
