-- |
-- Module:      Data.Geo.Jord.GeoPos
-- Copyright:   (c) 2018 Cedric Liegeois
-- License:     BSD3
-- Maintainer:  Cedric Liegeois <ofmooseandmen@yahoo.fr>
-- Stability:   experimental
-- Portability: portable
--
-- Types to represent a geographic position by its latitude and longitude.
--
module Data.Geo.Jord.GeoPos
    (
    -- * The 'GeoPos' type
      GeoPos(latitude, longitude)
    -- * Smart constructors
    , latLong
    , latLongE
    , latLongF
    , latLongDecimal
    , latLongDecimalE
    , latLongDecimalF
    -- * read
    , readGeoPos
    , readGeoPosE
    , readGeoPosF
    -- * Misc.
    , toDecimalDegrees'
    ) where

import Control.Applicative hiding (many)
import Control.Monad.Fail
import Data.Char
import Data.Geo.Jord.Angle
import Data.Geo.Jord.Parse
import Data.Maybe
import Prelude hiding (fail)
import Text.ParserCombinators.ReadP
import Text.Read hiding (pfail)

-- | A geographic position (latitude and longitude).
data GeoPos = GeoPos
    { latitude :: Angle
    , longitude :: Angle
    } deriving (Eq)

-- | See 'readGeoPos'.
instance Read GeoPos where
    readsPrec _ = readP_to_S geo

-- | Produced string format: d°(m')(s'')[N|S],d°(m')(s'')[E|W] - e.g. 55°36'21''N,13°0'2''E.
instance Show GeoPos where
    show (GeoPos lat lon) = showLat lat ++ "," ++ showLon lon

-- | 'GeoPos' from given latitude and longitude.
-- 'error's if given latitude is outisde [-90..90]° and/or
-- given longitude is outisde [-180..180]°.
latLong :: Angle -> Angle -> GeoPos
latLong lat lon =
    fromMaybe
        (error ("Invalid latitude=" ++ show lat ++ " or longitude=" ++ show lon))
        (latLongF lat lon)

-- | 'GeoPos' from given latitude and longitude.
-- A 'Left' indicates that the given latitude is outisde [-90..90]° and/or
-- given longitude is outisde [-180..180]°.
latLongE :: Angle -> Angle -> Either String GeoPos
latLongE lat lon
    | not (isWithin lat (decimalDegrees (-90)) (decimalDegrees 90)) =
        Left ("Invalid latitude=" ++ show lat)
    | not (isWithin lon (decimalDegrees (-180)) (decimalDegrees 180)) =
        Left ("Invalid longitude=" ++ show lon)
    | otherwise = Right (GeoPos lat lon)

-- | 'GeoPos' from given latitude and longitude.
-- 'fail's if given latitude is outisde [-90..90]° and/or
-- given longitude is outisde [-180..180]°.
latLongF :: (MonadFail m) => Angle -> Angle -> m GeoPos
latLongF lat lon =
    case e of
        Left err -> fail err
        Right g -> return g
  where
    e = latLongE lat lon

-- | 'GeoPos' from given latitude and longitude in decimal degrees.
-- 'error's if given latitude is outisde [-90..90]° and/or
-- given longitude is outisde [-180..180]°.
latLongDecimal :: Double -> Double -> GeoPos
latLongDecimal lat lon = latLong (decimalDegrees lat) (decimalDegrees lon)

-- | 'GeoPos' from given latitude and longitude in decimal degrees.
-- A 'Left' indicates that the given latitude is outisde [-90..90]° and/or
-- given longitude is outisde [-180..180]°.
latLongDecimalE :: Double -> Double -> Either String GeoPos
latLongDecimalE lat lon = latLongE (decimalDegrees lat) (decimalDegrees lon)

-- | 'GeoPos' from given latitude and longitude in decimal degrees.
-- 'fail's if given latitude is outisde [-90..90]° and/or
-- given longitude is outisde [-180..180]°.
latLongDecimalF :: (MonadFail m) => Double -> Double -> m GeoPos
latLongDecimalF lat lon = latLongF (decimalDegrees lat) (decimalDegrees lon)

-- | Obtains a 'GeoPos' from the given string formatted as either:
--
--     * DD(MM)(SS)[N|S]DDD(MM)(SS)[E|W] - e.g. 553621N0130002E or 0116S03649E or 47N122W
--
--     * 'Angle'[N|S] 'Angle'[E|W] - e.g. 55°36'21''N 13°0'02''E or 11°16'S 36°49'E or 47°N 122°W
--
-- This simply calls @read s :: GeoPos@ so 'error' should be handled at the call site.
--
readGeoPos :: String -> GeoPos
readGeoPos s = read s :: GeoPos

-- | Same as 'readGeoPos' but returns a 'Either'.
readGeoPosE :: String -> Either String GeoPos
readGeoPosE s =
    case readMaybe s of
        Nothing -> Left ("couldn't read geo pos " ++ s)
        Just g -> Right g

-- | Same as 'readGeoPos' but returns a 'MonadFail'.
readGeoPosF :: (MonadFail m) => String -> m GeoPos
readGeoPosF s =
    let pg = readGeoPosE s
     in case pg of
            Left e -> fail e
            Right g -> return g

-- | Converts the given 'GeoPos' to tuple of latitude and longitude in decimal degrees.
toDecimalDegrees' :: GeoPos -> (Double, Double)
toDecimalDegrees' g = (toDecimalDegrees (latitude g), toDecimalDegrees (longitude g))

-- | Parses and returns a 'GeoPos'.
geo :: ReadP GeoPos
geo = block <|> human

-- | Parses and returns a 'GeoPos' - DD(D)MMSS.
block :: ReadP GeoPos
block = do
    lat <- blat
    lon <- blon
    latLongF lat lon

-- | Parses and returns a latitude, DDMMSS expected.
blat :: ReadP Angle
blat = do
    d' <- digits 2
    (m', s') <- option (0, 0) (ms <|> m)
    h <- hemisphere
    if h == 'N'
        then dmsF d' m' s' 0
        else dmsF (-d') m' s' 0

-- | Parses and returns a longitude, DDDMMSS expected.
blon :: ReadP Angle
blon = do
    d' <- digits 3
    (m', s') <- option (0, 0) (ms <|> m)
    m'' <- meridian
    if m'' == 'E'
        then dmsF d' m' s' 0
        else dmsF (-d') m' s' 0

-- | Parses N or S char.
hemisphere :: ReadP Char
hemisphere = char 'N' <|> char 'S'

-- | Parses E or W char.
meridian :: ReadP Char
meridian = char 'E' <|> char 'W'

-- | Parses minutes and seconds.
ms :: ReadP (Int, Int)
ms = do
    m' <- digits 2
    s' <- digits 2
    return (m', s')

-- | Parses minutes.
m :: ReadP (Int, Int)
m = do
    m' <- digits 2
    return (m', 0)

-- | Parses and returns a 'GeoPos' from a human friendly text - see 'Angle'.
human :: ReadP GeoPos
human = do
    lat <- hlat
    _ <- char ' ' <|> char ','
    lon <- hlon
    latLongF lat lon

-- | Parses and returns a latitude, 'Angle'N|S expected.
hlat :: ReadP Angle
hlat = do
    lat <- angle
    h <- hemisphere
    if h == 'N'
        then return lat
        else return (negate' lat)

-- | Parses and returns a longitude, 'Angle'E|W expected.
hlon :: ReadP Angle
hlon = do
    lon <- angle
    m' <- meridian
    if m' == 'E'
        then return lon
        else return (negate' lon)

-- | Latitude to string.
showLat :: Angle -> String
showLat lat
    | isNegative lat = show (negate' lat) ++ "S"
    | otherwise = show lat ++ "N"

-- | Longitude to string.
showLon :: Angle -> String
showLon lon
    | isNegative lon = show (negate' lon) ++ "W"
    | otherwise = show lon ++ "E"