{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE TypeApplications #-}

module Test.Context.ConcurrentSpec
  ( spec
  ) where

import Prelude
import Test.Hspec
import qualified Context
import qualified Control.Monad as Monad

data Thing = Thing
  { stuff :: Int
  } deriving stock (Eq, Show)

spec :: Spec
spec = do
  describe "forkIO" do
    describe "mineMay" do
      it "empty stores" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore @IO @Thing \store1 -> do
          Context.withEmptyStore @IO @Char \store2 -> do
            Monad.void $ Context.forkIO do
              Context.mineMay store1 `shouldReturn` Nothing
              Context.mineMay store2 `shouldReturn` Nothing
              Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "initially-empty stores with registered context" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore \store1 -> do
          Context.use store1 Thing { stuff = 1 } do
            Context.withEmptyStore \store2 -> do
              Context.use store2 'a' do
                Monad.void $ Context.forkIO do
                  Context.mineMay store1 `shouldReturn` Just Thing { stuff = 1 }
                  Context.mineMay store2 `shouldReturn` Just 'a'
                  Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "initially-empty stores with nested contexts" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore \store1 -> do
          Context.use store1 Thing { stuff = 1 } do
            Context.use store1 Thing { stuff = 2 } do
              Context.withEmptyStore \store2 -> do
                Context.use store2 'a' do
                  Context.use store2 'b' do
                    Monad.void $ Context.forkIO do
                      Context.mineMay store1 `shouldReturn` Just Thing { stuff = 2 }
                      Context.mineMay store2 `shouldReturn` Just 'b'
                      Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "non-empty stores" do
        threadDone <- Context.newEmptyMVar
        Context.withNonEmptyStore Thing { stuff = 1 } \store1 -> do
          Context.withNonEmptyStore 'a' \store2 -> do
            Monad.void $ Context.forkIO do
              Context.mineMay store1 `shouldReturn` Just Thing { stuff = 1 }
              Context.mineMay store2 `shouldReturn` Just 'a'
              Context.putMVar threadDone ()
        Context.takeMVar threadDone

  describe "forkFinally" do
    describe "mineMay" do
      it "empty stores" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore @IO @Thing \store1 -> do
          Context.withEmptyStore @IO @Char \store2 -> do
            let checkStores = do
                  Context.mineMay store1 `shouldReturn` Nothing
                  Context.mineMay store2 `shouldReturn` Nothing
            Monad.void $ Context.forkFinally checkStores \_eResult -> do
              checkStores
              Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "initially-empty stores with registered context" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore \store1 -> do
          Context.use store1 Thing { stuff = 1 } do
            Context.withEmptyStore \store2 -> do
              Context.use store2 'a' do
                let checkStores = do
                      Context.mineMay store1 `shouldReturn` Just Thing { stuff = 1 }
                      Context.mineMay store2 `shouldReturn` Just 'a'
                Monad.void $ Context.forkFinally checkStores \_eResult -> do
                  checkStores
                  Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "initially-empty stores with nested contexts" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore \store1 -> do
          Context.use store1 Thing { stuff = 1 } do
            Context.use store1 Thing { stuff = 2 } do
              Context.withEmptyStore \store2 -> do
                Context.use store2 'a' do
                  Context.use store2 'b' do
                    let checkStores = do
                          Context.mineMay store1 `shouldReturn` Just Thing { stuff = 2 }
                          Context.mineMay store2 `shouldReturn` Just 'b'
                    Monad.void $ Context.forkFinally checkStores \_eResult -> do
                      checkStores
                      Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "non-empty stores" do
        threadDone <- Context.newEmptyMVar
        Context.withNonEmptyStore Thing { stuff = 1 } \store1 -> do
          Context.withNonEmptyStore 'a' \store2 -> do
            let checkStores = do
                  Context.mineMay store1 `shouldReturn` Just Thing { stuff = 1 }
                  Context.mineMay store2 `shouldReturn` Just 'a'
            Monad.void $ Context.forkFinally checkStores \_eResult -> do
              checkStores
              Context.putMVar threadDone ()
        Context.takeMVar threadDone

  describe "forkIOWithUnmask" do
    describe "mineMay" do
      it "empty stores" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore @IO @Thing \store1 -> do
          Context.withEmptyStore @IO @Char \store2 -> do
            Monad.void $ Context.forkIOWithUnmask \_restore -> do
              Context.mineMay store1 `shouldReturn` Nothing
              Context.mineMay store2 `shouldReturn` Nothing
              Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "initially-empty stores with registered context" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore \store1 -> do
          Context.use store1 Thing { stuff = 1 } do
            Context.withEmptyStore \store2 -> do
              Context.use store2 'a' do
                Monad.void $ Context.forkIOWithUnmask \_restore -> do
                  Context.mineMay store1 `shouldReturn` Just Thing { stuff = 1 }
                  Context.mineMay store2 `shouldReturn` Just 'a'
                  Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "initially-empty stores with nested contexts" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore \store1 -> do
          Context.use store1 Thing { stuff = 1 } do
            Context.use store1 Thing { stuff = 2 } do
              Context.withEmptyStore \store2 -> do
                Context.use store2 'a' do
                  Context.use store2 'b' do
                    Monad.void $ Context.forkIOWithUnmask \_restore -> do
                      Context.mineMay store1 `shouldReturn` Just Thing { stuff = 2 }
                      Context.mineMay store2 `shouldReturn` Just 'b'
                      Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "non-empty stores" do
        threadDone <- Context.newEmptyMVar
        Context.withNonEmptyStore Thing { stuff = 1 } \store1 -> do
          Context.withNonEmptyStore 'a' \store2 -> do
            Monad.void $ Context.forkIOWithUnmask \_restore -> do
              Context.mineMay store1 `shouldReturn` Just Thing { stuff = 1 }
              Context.mineMay store2 `shouldReturn` Just 'a'
              Context.putMVar threadDone ()
        Context.takeMVar threadDone

  describe "forkOn" do
    describe "mineMay" do
      it "empty stores" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore @IO @Thing \store1 -> do
          Context.withEmptyStore @IO @Char \store2 -> do
            Monad.void $ Context.forkOn 1 do
              Context.mineMay store1 `shouldReturn` Nothing
              Context.mineMay store2 `shouldReturn` Nothing
              Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "initially-empty stores with registered context" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore \store1 -> do
          Context.use store1 Thing { stuff = 1 } do
            Context.withEmptyStore \store2 -> do
              Context.use store2 'a' do
                Monad.void $ Context.forkOn 1 do
                  Context.mineMay store1 `shouldReturn` Just Thing { stuff = 1 }
                  Context.mineMay store2 `shouldReturn` Just 'a'
                  Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "initially-empty stores with nested contexts" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore \store1 -> do
          Context.use store1 Thing { stuff = 1 } do
            Context.use store1 Thing { stuff = 2 } do
              Context.withEmptyStore \store2 -> do
                Context.use store2 'a' do
                  Context.use store2 'b' do
                    Monad.void $ Context.forkOn 1 do
                      Context.mineMay store1 `shouldReturn` Just Thing { stuff = 2 }
                      Context.mineMay store2 `shouldReturn` Just 'b'
                      Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "non-empty stores" do
        threadDone <- Context.newEmptyMVar
        Context.withNonEmptyStore Thing { stuff = 1 } \store1 -> do
          Context.withNonEmptyStore 'a' \store2 -> do
            Monad.void $ Context.forkOn 1 do
              Context.mineMay store1 `shouldReturn` Just Thing { stuff = 1 }
              Context.mineMay store2 `shouldReturn` Just 'a'
              Context.putMVar threadDone ()
        Context.takeMVar threadDone

  describe "forkOnWithUnmask" do
    describe "mineMay" do
      it "empty stores" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore @IO @Thing \store1 -> do
          Context.withEmptyStore @IO @Char \store2 -> do
            Monad.void $ Context.forkOnWithUnmask 1 \_restore -> do
              Context.mineMay store1 `shouldReturn` Nothing
              Context.mineMay store2 `shouldReturn` Nothing
              Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "initially-empty stores with registered context" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore \store1 -> do
          Context.use store1 Thing { stuff = 1 } do
            Context.withEmptyStore \store2 -> do
              Context.use store2 'a' do
                Monad.void $ Context.forkOnWithUnmask 1 \_restore -> do
                  Context.mineMay store1 `shouldReturn` Just Thing { stuff = 1 }
                  Context.mineMay store2 `shouldReturn` Just 'a'
                  Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "initially-empty stores with nested contexts" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore \store1 -> do
          Context.use store1 Thing { stuff = 1 } do
            Context.use store1 Thing { stuff = 2 } do
              Context.withEmptyStore \store2 -> do
                Context.use store2 'a' do
                  Context.use store2 'b' do
                    Monad.void $ Context.forkOnWithUnmask 1 \_restore -> do
                      Context.mineMay store1 `shouldReturn` Just Thing { stuff = 2 }
                      Context.mineMay store2 `shouldReturn` Just 'b'
                      Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "non-empty stores" do
        threadDone <- Context.newEmptyMVar
        Context.withNonEmptyStore Thing { stuff = 1 } \store1 -> do
          Context.withNonEmptyStore 'a' \store2 -> do
            Monad.void $ Context.forkOnWithUnmask 1 \_restore -> do
              Context.mineMay store1 `shouldReturn` Just Thing { stuff = 1 }
              Context.mineMay store2 `shouldReturn` Just 'a'
              Context.putMVar threadDone ()
        Context.takeMVar threadDone

  describe "forkOS" do
    describe "mineMay" do
      it "empty stores" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore @IO @Thing \store1 -> do
          Context.withEmptyStore @IO @Char \store2 -> do
            Monad.void $ Context.forkOS do
              Context.mineMay store1 `shouldReturn` Nothing
              Context.mineMay store2 `shouldReturn` Nothing
              Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "initially-empty stores with registered context" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore \store1 -> do
          Context.use store1 Thing { stuff = 1 } do
            Context.withEmptyStore \store2 -> do
              Context.use store2 'a' do
                Monad.void $ Context.forkOS do
                  Context.mineMay store1 `shouldReturn` Just Thing { stuff = 1 }
                  Context.mineMay store2 `shouldReturn` Just 'a'
                  Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "initially-empty stores with nested contexts" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore \store1 -> do
          Context.use store1 Thing { stuff = 1 } do
            Context.use store1 Thing { stuff = 2 } do
              Context.withEmptyStore \store2 -> do
                Context.use store2 'a' do
                  Context.use store2 'b' do
                    Monad.void $ Context.forkOS do
                      Context.mineMay store1 `shouldReturn` Just Thing { stuff = 2 }
                      Context.mineMay store2 `shouldReturn` Just 'b'
                      Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "non-empty stores" do
        threadDone <- Context.newEmptyMVar
        Context.withNonEmptyStore Thing { stuff = 1 } \store1 -> do
          Context.withNonEmptyStore 'a' \store2 -> do
            Monad.void $ Context.forkOS do
              Context.mineMay store1 `shouldReturn` Just Thing { stuff = 1 }
              Context.mineMay store2 `shouldReturn` Just 'a'
              Context.putMVar threadDone ()
        Context.takeMVar threadDone

  describe "forkOSWithUnmask" do
    describe "mineMay" do
      it "empty stores" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore @IO @Thing \store1 -> do
          Context.withEmptyStore @IO @Char \store2 -> do
            Monad.void $ Context.forkOSWithUnmask \_restore -> do
              Context.mineMay store1 `shouldReturn` Nothing
              Context.mineMay store2 `shouldReturn` Nothing
              Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "initially-empty stores with registered context" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore \store1 -> do
          Context.use store1 Thing { stuff = 1 } do
            Context.withEmptyStore \store2 -> do
              Context.use store2 'a' do
                Monad.void $ Context.forkOSWithUnmask \_restore -> do
                  Context.mineMay store1 `shouldReturn` Just Thing { stuff = 1 }
                  Context.mineMay store2 `shouldReturn` Just 'a'
                  Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "initially-empty stores with nested contexts" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore \store1 -> do
          Context.use store1 Thing { stuff = 1 } do
            Context.use store1 Thing { stuff = 2 } do
              Context.withEmptyStore \store2 -> do
                Context.use store2 'a' do
                  Context.use store2 'b' do
                    Monad.void $ Context.forkOSWithUnmask \_restore -> do
                      Context.mineMay store1 `shouldReturn` Just Thing { stuff = 2 }
                      Context.mineMay store2 `shouldReturn` Just 'b'
                      Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "non-empty stores" do
        threadDone <- Context.newEmptyMVar
        Context.withNonEmptyStore Thing { stuff = 1 } \store1 -> do
          Context.withNonEmptyStore 'a' \store2 -> do
            Monad.void $ Context.forkOSWithUnmask \_restore -> do
              Context.mineMay store1 `shouldReturn` Just Thing { stuff = 1 }
              Context.mineMay store2 `shouldReturn` Just 'a'
              Context.putMVar threadDone ()
        Context.takeMVar threadDone

  describe "runInBoundThread" do
    describe "mineMay" do
      it "empty stores" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore @IO @Thing \store1 -> do
          Context.withEmptyStore @IO @Char \store2 -> do
            Context.runInBoundThread do
              Context.mineMay store1 `shouldReturn` Nothing
              Context.mineMay store2 `shouldReturn` Nothing
              Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "initially-empty stores with registered context" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore \store1 -> do
          Context.use store1 Thing { stuff = 1 } do
            Context.withEmptyStore \store2 -> do
              Context.use store2 'a' do
                Context.runInBoundThread do
                  Context.mineMay store1 `shouldReturn` Just Thing { stuff = 1 }
                  Context.mineMay store2 `shouldReturn` Just 'a'
                  Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "initially-empty stores with nested contexts" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore \store1 -> do
          Context.use store1 Thing { stuff = 1 } do
            Context.use store1 Thing { stuff = 2 } do
              Context.withEmptyStore \store2 -> do
                Context.use store2 'a' do
                  Context.use store2 'b' do
                    Context.runInBoundThread do
                      Context.mineMay store1 `shouldReturn` Just Thing { stuff = 2 }
                      Context.mineMay store2 `shouldReturn` Just 'b'
                      Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "non-empty stores" do
        threadDone <- Context.newEmptyMVar
        Context.withNonEmptyStore Thing { stuff = 1 } \store1 -> do
          Context.withNonEmptyStore 'a' \store2 -> do
            Context.runInBoundThread do
              Context.mineMay store1 `shouldReturn` Just Thing { stuff = 1 }
              Context.mineMay store2 `shouldReturn` Just 'a'
              Context.putMVar threadDone ()
        Context.takeMVar threadDone

  describe "runInUnboundThread" do
    describe "mineMay" do
      it "empty stores" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore @IO @Thing \store1 -> do
          Context.withEmptyStore @IO @Char \store2 -> do
            Context.runInUnboundThread do
              Context.mineMay store1 `shouldReturn` Nothing
              Context.mineMay store2 `shouldReturn` Nothing
              Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "initially-empty stores with registered context" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore \store1 -> do
          Context.use store1 Thing { stuff = 1 } do
            Context.withEmptyStore \store2 -> do
              Context.use store2 'a' do
                Context.runInUnboundThread do
                  Context.mineMay store1 `shouldReturn` Just Thing { stuff = 1 }
                  Context.mineMay store2 `shouldReturn` Just 'a'
                  Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "initially-empty stores with nested contexts" do
        threadDone <- Context.newEmptyMVar
        Context.withEmptyStore \store1 -> do
          Context.use store1 Thing { stuff = 1 } do
            Context.use store1 Thing { stuff = 2 } do
              Context.withEmptyStore \store2 -> do
                Context.use store2 'a' do
                  Context.use store2 'b' do
                    Context.runInUnboundThread do
                      Context.mineMay store1 `shouldReturn` Just Thing { stuff = 2 }
                      Context.mineMay store2 `shouldReturn` Just 'b'
                      Context.putMVar threadDone ()
        Context.takeMVar threadDone
      it "non-empty stores" do
        threadDone <- Context.newEmptyMVar
        Context.withNonEmptyStore Thing { stuff = 1 } \store1 -> do
          Context.withNonEmptyStore 'a' \store2 -> do
            Context.runInUnboundThread do
              Context.mineMay store1 `shouldReturn` Just Thing { stuff = 1 }
              Context.mineMay store2 `shouldReturn` Just 'a'
              Context.putMVar threadDone ()
        Context.takeMVar threadDone