module Data.Internal.Wkt.Point
  ( point
  , multiPoint
  , justPointsXY
  , justPointsXYZ
  , justPointsXYZM
  , emptyPoint
  , emptyMultiPoint
  ) where

import           Control.Applicative      ((<|>))
import qualified Data.Geospatial          as Geospatial
import qualified Data.Internal.Wkt.Common as Wkt
import qualified Data.Scientific          as Scientific
import qualified Data.Sequence            as Sequence
import qualified Text.Trifecta            as Trifecta

point :: Trifecta.Parser Geospatial.GeoPoint
point :: Parser GeoPoint
point = do
  String
_ <- String -> Parser String
forall (m :: * -> *). CharParsing m => String -> m String
Trifecta.string String
"point"
  ()
_ <- Parser ()
forall (m :: * -> *). CharParsing m => m ()
Trifecta.spaces
  (String -> Parser String
forall (m :: * -> *). CharParsing m => String -> m String
Trifecta.string String
"empty" Parser String -> Parser GeoPoint -> Parser GeoPoint
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> GeoPoint -> Parser GeoPoint
forall (f :: * -> *) a. Applicative f => a -> f a
pure GeoPoint
emptyPoint) Parser GeoPoint -> Parser GeoPoint -> Parser GeoPoint
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser GeoPoint
nonEmptyPoints

nonEmptyPoints :: Trifecta.Parser Geospatial.GeoPoint
nonEmptyPoints :: Parser GeoPoint
nonEmptyPoints =
  (String -> Parser String
forall (m :: * -> *). CharParsing m => String -> m String
Trifecta.string String
"zm" Parser String -> Parser GeoPoint -> Parser GeoPoint
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (GeoPositionWithoutCRS -> GeoPoint)
-> Parser GeoPositionWithoutCRS -> Parser GeoPoint
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GeoPositionWithoutCRS -> GeoPoint
Geospatial.GeoPoint (Parser GeoPositionWithoutCRS -> Parser GeoPositionWithoutCRS
bracketedPoint Parser GeoPositionWithoutCRS
justPointsXYZM))
  Parser GeoPoint -> Parser GeoPoint -> Parser GeoPoint
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (String -> Parser String
forall (m :: * -> *). CharParsing m => String -> m String
Trifecta.string String
"z" Parser String -> Parser GeoPoint -> Parser GeoPoint
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (GeoPositionWithoutCRS -> GeoPoint)
-> Parser GeoPositionWithoutCRS -> Parser GeoPoint
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GeoPositionWithoutCRS -> GeoPoint
Geospatial.GeoPoint (Parser GeoPositionWithoutCRS -> Parser GeoPositionWithoutCRS
bracketedPoint Parser GeoPositionWithoutCRS
justPointsXYZ))
  Parser GeoPoint -> Parser GeoPoint -> Parser GeoPoint
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (GeoPositionWithoutCRS -> GeoPoint)
-> Parser GeoPositionWithoutCRS -> Parser GeoPoint
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GeoPositionWithoutCRS -> GeoPoint
Geospatial.GeoPoint (Parser GeoPositionWithoutCRS -> Parser GeoPositionWithoutCRS
bracketedPoint Parser GeoPositionWithoutCRS
justPointsXY)

multiPoint :: Trifecta.Parser Geospatial.GeoMultiPoint
multiPoint :: Parser GeoMultiPoint
multiPoint = do
  String
_ <- String -> Parser String
forall (m :: * -> *). CharParsing m => String -> m String
Trifecta.string String
"multipoint"
  ()
_ <- Parser ()
forall (m :: * -> *). CharParsing m => m ()
Trifecta.spaces
  Seq GeoPositionWithoutCRS
xl <- Parser (Seq GeoPositionWithoutCRS)
forall a. Parser (Seq a)
Wkt.emptySet Parser (Seq GeoPositionWithoutCRS)
-> Parser (Seq GeoPositionWithoutCRS)
-> Parser (Seq GeoPositionWithoutCRS)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (Seq GeoPositionWithoutCRS)
nonEmptyMultipoints
  GeoMultiPoint -> Parser GeoMultiPoint
forall (f :: * -> *) a. Applicative f => a -> f a
pure (GeoMultiPoint -> Parser GeoMultiPoint)
-> GeoMultiPoint -> Parser GeoMultiPoint
forall a b. (a -> b) -> a -> b
$ Seq GeoPositionWithoutCRS -> GeoMultiPoint
Geospatial.GeoMultiPoint Seq GeoPositionWithoutCRS
xl

nonEmptyMultipoints :: Trifecta.Parser (Sequence.Seq Geospatial.GeoPositionWithoutCRS)
nonEmptyMultipoints :: Parser (Seq GeoPositionWithoutCRS)
nonEmptyMultipoints =
  (String -> Parser String
forall (m :: * -> *). CharParsing m => String -> m String
Trifecta.string String
"zm" Parser String
-> Parser (Seq GeoPositionWithoutCRS)
-> Parser (Seq GeoPositionWithoutCRS)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser GeoPositionWithoutCRS -> Parser (Seq GeoPositionWithoutCRS)
manyPoints Parser GeoPositionWithoutCRS
justPointsXYZM)
  Parser (Seq GeoPositionWithoutCRS)
-> Parser (Seq GeoPositionWithoutCRS)
-> Parser (Seq GeoPositionWithoutCRS)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (String -> Parser String
forall (m :: * -> *). CharParsing m => String -> m String
Trifecta.string String
"z" Parser String
-> Parser (Seq GeoPositionWithoutCRS)
-> Parser (Seq GeoPositionWithoutCRS)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser GeoPositionWithoutCRS -> Parser (Seq GeoPositionWithoutCRS)
manyPoints Parser GeoPositionWithoutCRS
justPointsXYZ)
  Parser (Seq GeoPositionWithoutCRS)
-> Parser (Seq GeoPositionWithoutCRS)
-> Parser (Seq GeoPositionWithoutCRS)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser GeoPositionWithoutCRS -> Parser (Seq GeoPositionWithoutCRS)
manyPoints Parser GeoPositionWithoutCRS
justPointsXY

manyPoints :: Trifecta.Parser Geospatial.GeoPositionWithoutCRS -> Trifecta.Parser (Sequence.Seq Geospatial.GeoPositionWithoutCRS)
manyPoints :: Parser GeoPositionWithoutCRS -> Parser (Seq GeoPositionWithoutCRS)
manyPoints Parser GeoPositionWithoutCRS
pointParser = do
  ()
_ <- Parser ()
forall (m :: * -> *). CharParsing m => m ()
Trifecta.spaces Parser () -> Parser Char -> Parser Char
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Parser Char
forall (m :: * -> *). CharParsing m => Char -> m Char
Trifecta.char Char
'(' Parser Char -> Parser () -> Parser ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser ()
forall (m :: * -> *). CharParsing m => m ()
Trifecta.spaces
  Seq GeoPositionWithoutCRS
xl <- Parser GeoPositionWithoutCRS -> Parser (Seq GeoPositionWithoutCRS)
unbracketedPoints Parser GeoPositionWithoutCRS
pointParser Parser (Seq GeoPositionWithoutCRS)
-> Parser (Seq GeoPositionWithoutCRS)
-> Parser (Seq GeoPositionWithoutCRS)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser GeoPositionWithoutCRS -> Parser (Seq GeoPositionWithoutCRS)
bracketedPoints Parser GeoPositionWithoutCRS
pointParser
  ()
_ <- Parser ()
forall (m :: * -> *). CharParsing m => m ()
Trifecta.spaces Parser () -> Parser Char -> Parser Char
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Parser Char
forall (m :: * -> *). CharParsing m => Char -> m Char
Trifecta.char Char
')' Parser Char -> Parser () -> Parser ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser ()
forall (m :: * -> *). CharParsing m => m ()
Trifecta.spaces
  Seq GeoPositionWithoutCRS -> Parser (Seq GeoPositionWithoutCRS)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Seq GeoPositionWithoutCRS
xl

unbracketedPoints :: Trifecta.Parser Geospatial.GeoPositionWithoutCRS -> Trifecta.Parser (Sequence.Seq Geospatial.GeoPositionWithoutCRS)
unbracketedPoints :: Parser GeoPositionWithoutCRS -> Parser (Seq GeoPositionWithoutCRS)
unbracketedPoints Parser GeoPositionWithoutCRS
pointParser = do
  GeoPositionWithoutCRS
x <- Parser GeoPositionWithoutCRS
pointParser
  [GeoPositionWithoutCRS]
xs <- Parser GeoPositionWithoutCRS -> Parser [GeoPositionWithoutCRS]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
Trifecta.many (Char -> Parser Char
forall (m :: * -> *). CharParsing m => Char -> m Char
Trifecta.char Char
',' Parser Char -> Parser () -> Parser ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser ()
forall (m :: * -> *). CharParsing m => m ()
Trifecta.spaces Parser ()
-> Parser GeoPositionWithoutCRS -> Parser GeoPositionWithoutCRS
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser GeoPositionWithoutCRS
pointParser )
  Seq GeoPositionWithoutCRS -> Parser (Seq GeoPositionWithoutCRS)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Seq GeoPositionWithoutCRS -> Parser (Seq GeoPositionWithoutCRS))
-> Seq GeoPositionWithoutCRS -> Parser (Seq GeoPositionWithoutCRS)
forall a b. (a -> b) -> a -> b
$ GeoPositionWithoutCRS
x GeoPositionWithoutCRS
-> Seq GeoPositionWithoutCRS -> Seq GeoPositionWithoutCRS
forall a. a -> Seq a -> Seq a
Sequence.<| [GeoPositionWithoutCRS] -> Seq GeoPositionWithoutCRS
forall a. [a] -> Seq a
Sequence.fromList [GeoPositionWithoutCRS]
xs

bracketedPoints :: Trifecta.Parser Geospatial.GeoPositionWithoutCRS -> Trifecta.Parser (Sequence.Seq Geospatial.GeoPositionWithoutCRS)
bracketedPoints :: Parser GeoPositionWithoutCRS -> Parser (Seq GeoPositionWithoutCRS)
bracketedPoints Parser GeoPositionWithoutCRS
pointParser = do
  GeoPositionWithoutCRS
x <- Parser GeoPositionWithoutCRS -> Parser GeoPositionWithoutCRS
bracketedPoint Parser GeoPositionWithoutCRS
pointParser
  [GeoPositionWithoutCRS]
xs <- Parser GeoPositionWithoutCRS -> Parser [GeoPositionWithoutCRS]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
Trifecta.many (Char -> Parser Char
forall (m :: * -> *). CharParsing m => Char -> m Char
Trifecta.char Char
',' Parser Char -> Parser () -> Parser ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser ()
forall (m :: * -> *). CharParsing m => m ()
Trifecta.spaces Parser ()
-> Parser GeoPositionWithoutCRS -> Parser GeoPositionWithoutCRS
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser GeoPositionWithoutCRS -> Parser GeoPositionWithoutCRS
bracketedPoint Parser GeoPositionWithoutCRS
pointParser)
  Seq GeoPositionWithoutCRS -> Parser (Seq GeoPositionWithoutCRS)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Seq GeoPositionWithoutCRS -> Parser (Seq GeoPositionWithoutCRS))
-> Seq GeoPositionWithoutCRS -> Parser (Seq GeoPositionWithoutCRS)
forall a b. (a -> b) -> a -> b
$ GeoPositionWithoutCRS
x GeoPositionWithoutCRS
-> Seq GeoPositionWithoutCRS -> Seq GeoPositionWithoutCRS
forall a. a -> Seq a -> Seq a
Sequence.<| [GeoPositionWithoutCRS] -> Seq GeoPositionWithoutCRS
forall a. [a] -> Seq a
Sequence.fromList [GeoPositionWithoutCRS]
xs

bracketedPoint :: Trifecta.Parser Geospatial.GeoPositionWithoutCRS -> Trifecta.Parser Geospatial.GeoPositionWithoutCRS
bracketedPoint :: Parser GeoPositionWithoutCRS -> Parser GeoPositionWithoutCRS
bracketedPoint Parser GeoPositionWithoutCRS
pointParser = do
  ()
_ <- Parser ()
forall (m :: * -> *). CharParsing m => m ()
Trifecta.spaces Parser () -> Parser Char -> Parser Char
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Parser Char
forall (m :: * -> *). CharParsing m => Char -> m Char
Trifecta.char Char
'(' Parser Char -> Parser () -> Parser ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser ()
forall (m :: * -> *). CharParsing m => m ()
Trifecta.spaces
  GeoPositionWithoutCRS
x <- Parser GeoPositionWithoutCRS
pointParser
  ()
_ <- Parser ()
forall (m :: * -> *). CharParsing m => m ()
Trifecta.spaces Parser () -> Parser Char -> Parser Char
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Parser Char
forall (m :: * -> *). CharParsing m => Char -> m Char
Trifecta.char Char
')' Parser Char -> Parser () -> Parser ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser ()
forall (m :: * -> *). CharParsing m => m ()
Trifecta.spaces
  GeoPositionWithoutCRS -> Parser GeoPositionWithoutCRS
forall (f :: * -> *) a. Applicative f => a -> f a
pure GeoPositionWithoutCRS
x

firstXy :: Trifecta.Parser (Scientific.Scientific, Scientific.Scientific)
firstXy :: Parser (Scientific, Scientific)
firstXy = do
  Scientific
x <- Parser Scientific
Wkt.number
  ()
_ <- Parser ()
forall (m :: * -> *). CharParsing m => m ()
Trifecta.spaces
  Scientific
y <- Parser Scientific
Wkt.number
  (Scientific, Scientific) -> Parser (Scientific, Scientific)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Scientific
x, Scientific
y)

firstXyz :: Trifecta.Parser (Scientific.Scientific, Scientific.Scientific, Scientific.Scientific)
firstXyz :: Parser (Scientific, Scientific, Scientific)
firstXyz = do
  (Scientific
x, Scientific
y) <- Parser (Scientific, Scientific)
firstXy
  ()
_ <- Parser ()
forall (m :: * -> *). CharParsing m => m ()
Trifecta.spaces
  Scientific
z <- Parser Scientific
Wkt.number
  (Scientific, Scientific, Scientific)
-> Parser (Scientific, Scientific, Scientific)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Scientific
x, Scientific
y, Scientific
z)

justPointsXY :: Trifecta.Parser Geospatial.GeoPositionWithoutCRS
justPointsXY :: Parser GeoPositionWithoutCRS
justPointsXY = do
  (Scientific
x,Scientific
y) <- Parser (Scientific, Scientific)
firstXy
  let xy :: PointXY
xy = Double -> Double -> PointXY
Geospatial.PointXY (Scientific -> Double
forall a. RealFloat a => Scientific -> a
Scientific.toRealFloat Scientific
x) (Scientific -> Double
forall a. RealFloat a => Scientific -> a
Scientific.toRealFloat Scientific
y)
  GeoPositionWithoutCRS -> Parser GeoPositionWithoutCRS
forall (f :: * -> *) a. Applicative f => a -> f a
pure (GeoPositionWithoutCRS -> Parser GeoPositionWithoutCRS)
-> GeoPositionWithoutCRS -> Parser GeoPositionWithoutCRS
forall a b. (a -> b) -> a -> b
$ PointXY -> GeoPositionWithoutCRS
Geospatial.GeoPointXY PointXY
xy

justPointsXYZ :: Trifecta.Parser Geospatial.GeoPositionWithoutCRS
justPointsXYZ :: Parser GeoPositionWithoutCRS
justPointsXYZ = do
  (Scientific
x,Scientific
y,Scientific
z) <- Parser (Scientific, Scientific, Scientific)
firstXyz
  let xyz :: PointXYZ
xyz = Double -> Double -> Double -> PointXYZ
Geospatial.PointXYZ (Scientific -> Double
forall a. RealFloat a => Scientific -> a
Scientific.toRealFloat Scientific
x) (Scientific -> Double
forall a. RealFloat a => Scientific -> a
Scientific.toRealFloat Scientific
y) (Scientific -> Double
forall a. RealFloat a => Scientific -> a
Scientific.toRealFloat Scientific
z)
  GeoPositionWithoutCRS -> Parser GeoPositionWithoutCRS
forall (f :: * -> *) a. Applicative f => a -> f a
pure (GeoPositionWithoutCRS -> Parser GeoPositionWithoutCRS)
-> GeoPositionWithoutCRS -> Parser GeoPositionWithoutCRS
forall a b. (a -> b) -> a -> b
$ PointXYZ -> GeoPositionWithoutCRS
Geospatial.GeoPointXYZ PointXYZ
xyz

justPointsXYZM :: Trifecta.Parser Geospatial.GeoPositionWithoutCRS
justPointsXYZM :: Parser GeoPositionWithoutCRS
justPointsXYZM = do
  (Scientific
x,Scientific
y,Scientific
z) <- Parser (Scientific, Scientific, Scientific)
firstXyz
  ()
_ <- Parser ()
forall (m :: * -> *). CharParsing m => m ()
Trifecta.spaces
  Scientific
m <- Parser Scientific
Wkt.number
  let xyzm :: PointXYZM
xyzm = Double -> Double -> Double -> Double -> PointXYZM
Geospatial.PointXYZM (Scientific -> Double
forall a. RealFloat a => Scientific -> a
Scientific.toRealFloat Scientific
x) (Scientific -> Double
forall a. RealFloat a => Scientific -> a
Scientific.toRealFloat Scientific
y) (Scientific -> Double
forall a. RealFloat a => Scientific -> a
Scientific.toRealFloat Scientific
z) (Scientific -> Double
forall a. RealFloat a => Scientific -> a
Scientific.toRealFloat Scientific
m)
  GeoPositionWithoutCRS -> Parser GeoPositionWithoutCRS
forall (f :: * -> *) a. Applicative f => a -> f a
pure (GeoPositionWithoutCRS -> Parser GeoPositionWithoutCRS)
-> GeoPositionWithoutCRS -> Parser GeoPositionWithoutCRS
forall a b. (a -> b) -> a -> b
$ PointXYZM -> GeoPositionWithoutCRS
Geospatial.GeoPointXYZM PointXYZM
xyzm

emptyPoint :: Geospatial.GeoPoint
emptyPoint :: GeoPoint
emptyPoint = GeoPositionWithoutCRS -> GeoPoint
Geospatial.GeoPoint GeoPositionWithoutCRS
Geospatial.GeoEmpty

emptyMultiPoint :: Geospatial.GeoMultiPoint
emptyMultiPoint :: GeoMultiPoint
emptyMultiPoint = Seq GeoPositionWithoutCRS -> GeoMultiPoint
Geospatial.GeoMultiPoint Seq GeoPositionWithoutCRS
forall a. Seq a
Sequence.empty