module LibSpec where

import Protolude (
  Bool (True),
  ExitCode (ExitFailure),
  Maybe (..),
  Text,
  isJust,
  pure,
  show,
  ($),
  (&),
  (/=),
  (<),
  (<>),
  (==),
 )
import Protolude qualified as P

import Control.Arrow ((>>>))
import Data.Aeson (decode)
import Data.List.Utils (subIndex)
import Data.Text (unpack)
import Data.Text qualified as T
import Data.Time.ISO8601.Duration qualified as Iso
import Database.SQLite.Simple (SQLData (SQLNull), query_)
import Test.Hspec (
  Spec,
  context,
  it,
  shouldBe,
  shouldContain,
  shouldEndWith,
  shouldNotBe,
  shouldNotContain,
  shouldNotSatisfy,
  shouldSatisfy,
  shouldStartWith,
  shouldThrow,
 )

import Config (defaultConfig)
import Data.Hourglass (TimeFormat (..), timePrint)
import FullTask (FullTask, emptyFullTask)
import FullTask qualified
import ImportExport (EditMode (ApplyPreEdit), editTaskByTask)
import Lib (
  addNote,
  addTag,
  addTask,
  countTasks,
  deleteNote,
  deleteTag,
  deleteTasks,
  doTasks,
  duplicateTasks,
  headTasks,
  infoTask,
  insertRecord,
  insertTags,
  listNotes,
  logTask,
  newTasks,
  nextTask,
  recurTasks,
  repeatTasks,
  runFilter,
  setDueUtc,
  setReadyUtc,
  unrepeatTasks,
  updateTask,
 )
import Note (Note)
import System.Hourglass (dateCurrent)
import Task (
  Task (
    body,
    closed_utc,
    due_utc,
    group_ulid,
    metadata,
    modified_utc,
    ready_utc,
    repetition_duration,
    state,
    ulid,
    user
  ),
  TaskState (Done),
  emptyTask,
 )
import TaskToNote (TaskToNote (TaskToNote, ulid))
import TaskToNote qualified
import TaskToTag (TaskToTag)
import TaskToTag qualified
import TestUtils (withMemoryDb)
import Utils (parseUtc, zeroTime, zeroUlidTxt)


exampleTask :: Task
exampleTask =
  emptyTask
    { Task.ulid = "01hq68smfe0r9entg3x4rb9441"
    , Task.body = "Buy milk"
    , Task.state = Nothing
    , Task.modified_utc = "2024-02-21 16:43:17"
    , Task.due_utc = Just "2025-07-08 10:22:56"
    , Task.user = "john_vdg1c2hz"
    , Task.metadata = "{\"source\":\"fridge\"}" & decode
    }


task1 :: Task
task1 =
  emptyTask
    { Task.ulid = "01hs68z7mdg4ktpxbv0yfafznq"
    , Task.body = "New task 1"
    , Task.modified_utc = "2024-03-17 13:17:44.461"
    }


taskMultiLine :: Task
taskMultiLine =
  emptyTask
    { Task.ulid = "01hx48cnjhp18mts3c44zk3gen"
    , Task.body =
        "New task\n\
        \with several lines\n\
        \and line breaks"
    }


normTask :: Task -> Task
normTask task =
  task
    { Task.ulid = ""
    , Task.modified_utc = ""
    , Task.due_utc = Nothing
    , Task.user = ""
    }


replaceBs :: P.ByteString -> P.ByteString -> P.ByteString -> P.ByteString
replaceBs needle replacement haystack = do
  haystack
    & P.decodeUtf8
    & T.replace (P.decodeUtf8 needle) (P.decodeUtf8 replacement)
    & P.encodeUtf8


spec :: Spec
spec = do
  let
    now = "2024-05-08 10:04:17" & parseUtc & P.fromMaybe zeroTime
    conf = defaultConfig

  it "initially contains no tasks" $ do
    withMemoryDb conf $ \memConn -> do
      tasks <- headTasks conf now memConn Nothing
      unpack (show tasks) `shouldStartWith` "No tasks available"

  it "inserts a task" $ do
    withMemoryDb conf $ \memConn -> do
      let task =
            emptyTask
              { Task.ulid = "01hrvhc0h1pncbczxym16642mm"
              , Task.body = "Directly inserted task"
              , Task.state = Just Done
              }

      insertRecord "tasks" memConn task
      tasks :: [Task] <- query_ memConn "SELECT * FROM tasks"
      tasks `shouldBe` [task]

  it "adds a new task" $ do
    withMemoryDb conf $ \memConn -> do
      result <- addTask conf memConn ["Just a test"]
      unpack (show result)
        `shouldStartWith` "🆕 Added task \"Just a test\" with id"

  context "When a task exists" $ do
    it "updates a task" $ do
      withMemoryDb conf $ \memConn -> do
        let initialTask =
              emptyTask
                { Task.ulid = "01hrvhdddfwsrnp6dd8h7tp8h4"
                , Task.body = "New task"
                , Task.state = Just Done
                }
            newTask = initialTask{body = "Updated task"}

        insertRecord "tasks" memConn initialTask
        updateTask memConn newTask
        tasks :: [Task] <- query_ memConn "SELECT * FROM tasks"

        case tasks of
          [updatedTask] -> do
            -- Task should have a different `modified_utc` value
            updatedTask `shouldSatisfy` (\task -> task.modified_utc /= "")
            updatedTask{modified_utc = ""} `shouldBe` newTask
          _ ->
            P.die "Found more than one task"

    it "lists next task" $ do
      withMemoryDb conf $ \memConn -> do
        insertRecord "tasks" memConn exampleTask
        result <- nextTask conf memConn
        unpack (show result) `shouldContain` "Buy milk"

    it "adds a tag" $ do
      withMemoryDb conf $ \memConn -> do
        insertRecord "tasks" memConn exampleTask
        tagResult <- addTag conf memConn "test" [exampleTask.ulid]
        unpack (show tagResult)
          `shouldStartWith` "🏷  Added tag \"test\" to task"
        taskToTags :: [TaskToTag] <-
          query_ memConn "SELECT * FROM task_to_tag"
        case taskToTags of
          [taskToTag] -> do
            taskToTag.ulid `shouldNotBe` ""
            taskToTag.task_ulid `shouldNotBe` ""
            taskToTag.tag `shouldBe` "test"
          _ -> P.die "More than one task_to_tag row found"

    it "strips leading + when adding a tag" $ do
      withMemoryDb conf $ \memConn -> do
        insertRecord "tasks" memConn exampleTask
        tagResult <- addTag conf memConn "+test" [exampleTask.ulid]
        unpack (show tagResult)
          `shouldStartWith` "🏷  Added tag \"test\" to task"
        taskToTags :: [TaskToTag] <-
          query_ memConn "SELECT * FROM task_to_tag"
        case taskToTags of
          [taskToTag] -> taskToTag.tag `shouldBe` "test"
          _ -> P.die "More than one task_to_tag row found"

    it "deletes a tag" $ do
      withMemoryDb conf $ \memConn -> do
        insertRecord "tasks" memConn exampleTask
        _ <- addTag conf memConn "test" [exampleTask.ulid]
        delResult <- deleteTag conf memConn "test" [exampleTask.ulid]
        unpack (show delResult)
          `shouldStartWith` "💥 Removed tag \"test\" of task"
        taskToTags :: [TaskToTag] <-
          query_ memConn "SELECT * FROM task_to_tag"
        taskToTags `shouldBe` []

    it "doesn't delete a tag that does not exist" $ do
      withMemoryDb conf $ \memConn -> do
        insertRecord "tasks" memConn exampleTask
        delResult <- deleteTag conf memConn "test" [exampleTask.ulid]
        unpack (show delResult) `shouldContain` "not set"

    it "adds a note" $ do
      withMemoryDb conf $ \memConn -> do
        insertRecord "tasks" memConn exampleTask
        noteResult <- addNote conf memConn "A test note" [exampleTask.ulid]
        unpack (show noteResult)
          `shouldStartWith` "🗒  Added a note to task"

    -- it "correctly wraps multiline notes" $ do
    --   See error:
    --   tl info x795vqf

    it "sets due UTC" $ do
      withMemoryDb conf $ \memConn -> do
        insertRecord "tasks" memConn exampleTask
        let utcTxt = "2087-03-21 17:43:00"
        case parseUtc utcTxt of
          Nothing -> P.die "Invalid UTC string"
          Just utcStamp -> do
            result <- setDueUtc conf memConn utcStamp [exampleTask.ulid]
            unpack (show result)
              `shouldStartWith` ( "📅 Set due UTC of task \""
                                    <> T.unpack exampleTask.body
                                    <> "\" with id \""
                                    <> T.unpack exampleTask.ulid
                                    <> "\" to \""
                                    <> T.unpack utcTxt
                                    <> "\""
                                )

    it "sets ready UTC" $ do
      withMemoryDb conf $ \memConn -> do
        insertRecord "tasks" memConn exampleTask
        let utcTxt = "2059-07-11 04:55:16"
        case parseUtc utcTxt of
          Nothing -> P.die "Invalid UTC string"
          Just utcStamp -> do
            result <- setReadyUtc conf memConn utcStamp [exampleTask.ulid]
            unpack (show result)
              `shouldStartWith` ( "📅 Set ready UTC of task \""
                                    <> T.unpack exampleTask.body
                                    <> "\" with id \""
                                    <> T.unpack exampleTask.ulid
                                    <> "\" to \""
                                    <> T.unpack utcTxt
                                    <> "\""
                                )
            tasks :: [Task] <- query_ memConn "SELECT * FROM tasks"
            case tasks of
              [updatedTask] -> do
                updatedTask `shouldSatisfy` (\task -> isJust task.ready_utc)
              _ -> P.die "Found more than one task"

    it "completes it" $ do
      withMemoryDb conf $ \memConn -> do
        insertRecord "tasks" memConn exampleTask
        doResult <- doTasks conf memConn Nothing [exampleTask.ulid]
        unpack (show doResult) `shouldStartWith` "✅ Finished task"
        tasks :: [Task] <- query_ memConn "SELECT * FROM tasks"
        case tasks of
          [updatedTask] -> do
            updatedTask `shouldSatisfy` (\task -> task.state == Just Done)
            updatedTask `shouldSatisfy` (\task -> isJust task.closed_utc)
          _ -> P.die "Found more than one task"

    it "deletes it" $ do
      withMemoryDb conf $ \memConn -> do
        insertRecord "tasks" memConn exampleTask
        deleteResult <- deleteTasks conf memConn [exampleTask.ulid]
        unpack (show deleteResult) `shouldStartWith` "❌ Deleted task"
        tasks :: [Task] <- query_ memConn "SELECT * FROM tasks"
        tasks `shouldBe` []
        tags :: [TaskToTag] <- query_ memConn "SELECT * FROM task_to_tag"
        tags `shouldBe` []
        notes :: [Note] <- query_ memConn "SELECT * FROM task_to_note"
        notes `shouldBe` []

    it "duplicates a task" $ do
      withMemoryDb conf $ \memConn -> do
        insertRecord "tasks" memConn exampleTask
        duplicationResult <- duplicateTasks conf memConn [exampleTask.ulid]
        unpack (show duplicationResult)
          `shouldStartWith` "👯  Created a duplicate of task \"Buy milk\""
        tasks :: [Task] <- query_ memConn "SELECT * FROM tasks"
        case tasks of
          [taskA, taskB] -> do
            normTask taskA `shouldBe` normTask exampleTask
            normTask taskB `shouldBe` normTask exampleTask
          _ -> P.die "Must have exactly two tasks"

    it "deletes obsolete fields on duplication" $ do
      withMemoryDb conf $ \memConn -> do
        insertRecord "tasks" memConn exampleTask
        let
          zeroDur = Iso.DurationWeek (Iso.DurWeek 0)
          oneMonth = "P1M" & Iso.parseDuration & P.fromRight zeroDur
        _ <- repeatTasks conf memConn oneMonth [exampleTask.ulid]
        _ <- duplicateTasks conf memConn [exampleTask.ulid]
        tasks :: [Task] <-
          query_ memConn "SELECT * FROM tasks ORDER BY ulid DESC"
        case tasks of
          [dupe, original] -> do
            original.group_ulid `shouldSatisfy` P.isJust
            original.repetition_duration `shouldSatisfy` P.isJust
            dupe.group_ulid `shouldSatisfy` P.isNothing
            dupe.repetition_duration `shouldSatisfy` P.isNothing
            dupe.user `shouldNotBe` original.user
            normTask dupe `shouldBe` normTask exampleTask
          _ -> P.die "Must have exactly two tasks"

  it "adds a task with tags and due date" $ do
    withMemoryDb conf $ \memConn -> do
      _ <- addTask conf memConn ["Just a test +tag due:2082-10-03 +what"]
      (tasks :: [FullTask]) <- query_ memConn "SELECT * FROM tasks_view"
      case tasks of
        [updatedTask] -> do
          updatedTask `shouldSatisfy` (\task -> task.ulid /= "")
          updatedTask `shouldSatisfy` (\task -> task.modified_utc /= "")
          updatedTask `shouldSatisfy` (\task -> task.user /= "")
          updatedTask
            { FullTask.ulid = ""
            , FullTask.modified_utc = ""
            , FullTask.user = ""
            }
            `shouldBe` emptyFullTask
              { FullTask.body = "Just a test"
              , FullTask.due_utc = Just "2082-10-03 00:00:00"
              , FullTask.priority = Just 2.0
              , FullTask.tags = Just ["tag", "what"]
              }
        _ -> P.die "Found more than one task"

  it "deduplicates tags when adding a task" $ do
    withMemoryDb conf $ \memConn -> do
      _ <- addTask conf memConn ["Buy milk +drink +drink"]
      (tasks :: [FullTask]) <- query_ memConn "SELECT * FROM tasks_view"
      case tasks of
        [updatedTask] -> do
          updatedTask `shouldSatisfy` (\task -> task.ulid /= "")
          updatedTask `shouldSatisfy` (\task -> task.modified_utc /= "")
          updatedTask `shouldSatisfy` (\task -> task.user /= "")
          updatedTask
            { FullTask.ulid = ""
            , FullTask.modified_utc = ""
            , FullTask.user = ""
            }
            `shouldBe` emptyFullTask
              { FullTask.body = "Buy milk"
              , FullTask.priority = Just 2.0
              , FullTask.tags = Just ["drink"]
              }
        _ -> P.die "Found more than one task"

  it "logs a task" $ do
    withMemoryDb conf $ \memConn -> do
      result <- logTask conf memConn ["Just a test"]
      unpack (show result)
        `shouldStartWith` "📝 Logged task \"Just a test\" with id"

  it "dies on invalid filter expressions" $ do
    withMemoryDb conf $ \memConn -> do
      runFilter conf now memConn [" "] Nothing `shouldThrow` (== ExitFailure 1)

  it "counts tasks" $ do
    withMemoryDb defaultConfig $ \memConn -> do
      let
        task2 =
          emptyTask
            { Task.ulid = "01hs690f9hkzk9z7zews9j2k1d"
            , Task.body = "New task 2"
            }

      count0 <- countTasks defaultConfig memConn P.mempty
      show count0 `shouldBe` ("0" :: Text)

      insertRecord "tasks" memConn task1
      count1 <- countTasks defaultConfig memConn P.mempty
      show count1 `shouldBe` ("1" :: Text)

      insertRecord "tasks" memConn task2
      count2 <- countTasks defaultConfig memConn P.mempty
      show count2 `shouldBe` ("2" :: Text)

      warnings <- insertTags conf memConn Nothing task2 ["test"]
      P.show warnings `shouldBe` T.empty
      countWithTag <- countTasks defaultConfig memConn (Just ["+test"])
      show countWithTag `shouldBe` ("1" :: Text)

      pure ()

  it "gets new tasks" $ do
    withMemoryDb defaultConfig $ \memConn -> do
      let
        task2 =
          emptyTask
            { Task.ulid = "01hs6zsf3c0vqx6egfnmbqtmvy"
            , Task.body = "New task 2"
            , Task.closed_utc = Just "2024-04-10T18:54:10Z"
            , Task.state = Just Done
            }

      insertRecord "tasks" memConn task1
      insertRecord "tasks" memConn task2

      cliOutput <- newTasks defaultConfig now memConn (Just ["state:done"]) Nothing
      show cliOutput `shouldContain` "New task 2"
      show cliOutput `shouldNotContain` "New task 1"

  it "shows warning if a tag is duplicated" $ do
    withMemoryDb defaultConfig $ \memConn -> do
      let newTag = "test"
      insertRecord "tasks" memConn task1
      warnings <- insertTags conf memConn Nothing task1 [newTag]
      P.show warnings `shouldBe` T.empty

      cliOutput <- addTag defaultConfig memConn newTag [task1.ulid]
      show cliOutput `shouldEndWith` "Tag \"test\" is already assigned"

  it "repeats a task and prevents recurring same task" $ do
    withMemoryDb defaultConfig $ \memConn -> do
      insertRecord "tasks" memConn task1
      let oneWeek = Iso.DurationWeek (Iso.DurWeek 1)
      repeatRes <- repeatTasks defaultConfig memConn oneWeek [task1.ulid]
      P.show repeatRes `shouldContain` "Set repeat duration of task"

      recurRes <- recurTasks defaultConfig memConn oneWeek [task1.ulid]
      P.show recurRes `shouldContain` "is already in a repetition series"

      unrepeatRes <- unrepeatTasks defaultConfig memConn [task1.ulid]
      P.show unrepeatRes `shouldContain` "Removed repetition duration"

      recurRes2 <- recurTasks defaultConfig memConn oneWeek [task1.ulid]
      P.show recurRes2 `shouldContain` "Set recurrence duration of task"

      repeatRes2 <- repeatTasks defaultConfig memConn oneWeek [task1.ulid]
      P.show repeatRes2 `shouldContain` "is already in a recurrence series"

  context "Editing a task" $ do
    it "shows warning if a tag was duplicated" $ do
      withMemoryDb defaultConfig $ \memConn -> do
        let existTag = "existing-tag"
        insertRecord "tasks" memConn task1
        warnings <- insertTags conf memConn Nothing task1 [existTag]
        P.show warnings `shouldBe` T.empty
        cliOutput <-
          editTaskByTask
            conf
            ( ApplyPreEdit $
                replaceBs
                  "\n...\n"
                  ("\ntags: " <> P.show [existTag, "new-tag"] <> "\n...\n")
            )
            memConn
            task1
        let errMsg = "Tag \"" <> T.unpack existTag <> "\" is already assigned"
        show cliOutput `shouldContain` errMsg

    it "lets you change the closed_utc" $ do
      withMemoryDb defaultConfig $ \memConn -> do
        insertRecord "tasks" memConn task1

        cliOutput <-
          editTaskByTask
            conf
            ( ApplyPreEdit $
                replaceBs
                  "state: null"
                  "state: Done"
                  >>> replaceBs
                    "closed_utc: null"
                    "closed_utc: 2024-05-08 10:04"
            )
            memConn
            task1
        show cliOutput `shouldContain` "Edited task"
        tasks :: [Task] <- query_ memConn "SELECT * FROM tasks"
        case tasks of
          [task] -> do
            task.closed_utc `shouldBe` Just "2024-05-08 10:04:00.000"
            task.state `shouldBe` Just Done
            now_ <- dateCurrent
            let today = now_ & timePrint (toFormat ("YYYY-MM-DD" :: [P.Char]))
            T.unpack task.modified_utc `shouldStartWith` today
          _ -> P.die "Found more than one task"

    it "lets you add notes" $ do
      withMemoryDb defaultConfig $ \memConn -> do
        insertRecord "tasks" memConn task1
        cliOutput <-
          editTaskByTask
            conf
            ( ApplyPreEdit $
                replaceBs
                  "\n...\n"
                  ("\nnotes: " <> P.show ["A short note" :: Text] <> "\n...\n")
            )
            memConn
            task1
        show cliOutput `shouldStartWith` "✏️  Edited task \"New task 1\""

        taskToNotes :: [TaskToNote] <-
          query_ memConn "SELECT * FROM task_to_note"
        case taskToNotes of
          [taskToNote] -> do
            taskToNote.ulid
              `shouldNotSatisfy` (\ulid -> zeroUlidTxt `T.isPrefixOf` ulid)
            taskToNote.note `shouldBe` "A short note"
          _ -> P.die "Found more than one task_to_tag row"

    it "de-duplicates notes" $ do
      withMemoryDb defaultConfig $ \memConn -> do
        insertRecord "tasks" memConn task1
        let note = "A short note"
        insertRecord
          "task_to_note"
          memConn
          TaskToNote
            { TaskToNote.ulid = "01hxsjgzmdx48yzk39v852razr"
            , TaskToNote.task_ulid = task1.ulid
            , TaskToNote.note = note
            }
        taskInfo <- infoTask defaultConfig memConn task1.ulid
        show taskInfo `shouldContain` T.unpack note
        cliOutput <-
          editTaskByTask
            conf
            ( ApplyPreEdit $
                replaceBs "notes: []" $
                  "notes: " <> P.show [note, note]
            )
            memConn
            task1
        show cliOutput `shouldStartWith` "✏️  Edited task \"New task 1\""

        taskToNotes :: [TaskToNote] <-
          query_ memConn "SELECT * FROM task_to_note"
        case taskToNotes of
          [taskToNoteA, taskToNoteB] -> do
            taskToNoteA.ulid
              `shouldNotSatisfy` (\ulid -> zeroUlidTxt `T.isPrefixOf` ulid)
            taskToNoteB.ulid
              `shouldNotSatisfy` (\ulid -> zeroUlidTxt `T.isPrefixOf` ulid)
            taskToNoteA.note `shouldBe` "A short note"
            taskToNoteB.note `shouldBe` "A short note"
          _ -> P.die "Found more than one task_to_tag row"

    it "lets you set metadata to null" $ do
      withMemoryDb defaultConfig $ \memConn -> do
        insertRecord "tasks" memConn task1{metadata = Just "{\"a\":\"b\"}"}
        cliOutput <-
          editTaskByTask
            conf
            (ApplyPreEdit $ replaceBs "\n...\n" "\nmetadata: null\n...\n")
            memConn
            task1
        show cliOutput `shouldStartWith` "✏️  Edited task \"New task 1\""
        tasks :: [[SQLData]] <- query_ memConn "SELECT metadata FROM tasks"
        case tasks of
          [[metadata]] -> do
            metadata `shouldBe` SQLNull
          _ -> P.die "Found more than one task"

  it "only shows first line of multi-line tasks in task listing" $ do
    withMemoryDb defaultConfig $ \memConn -> do
      insertRecord "tasks" memConn taskMultiLine

      tasks <- headTasks conf now memConn Nothing
      show tasks `shouldContain` "New task ▼"
      show tasks `shouldNotContain` "with several lines"

  it "keeps line breaks of multi-line tasks in info view" $ do
    withMemoryDb defaultConfig $ \memConn -> do
      insertRecord "tasks" memConn taskMultiLine

      cliOutput <- infoTask defaultConfig memConn taskMultiLine.ulid
      show cliOutput
        `shouldContain` "New task\n\
                        \with several lines\n\
                        \and line breaks"

  it "lists all notes descending by creation UTC" $ do
    withMemoryDb defaultConfig $ \memConn -> do
      insertRecord "tasks" memConn task1
      let
        taskToNote1 =
          TaskToNote
            { TaskToNote.ulid = "01hx4eyxxvs5b75ynxrztcz87f"
            , TaskToNote.task_ulid = task1.ulid
            , TaskToNote.note = "The first note"
            }
        note1Id = taskToNote1.ulid & T.takeEnd 3 & T.unpack
        taskToNote2 =
          TaskToNote
            { TaskToNote.ulid = "01hx4f3f764sma7n8bahvwjeed"
            , TaskToNote.task_ulid = task1.ulid
            , TaskToNote.note = "The second note"
            }
        note2Id = taskToNote2.ulid & T.takeEnd 3 & T.unpack

      insertRecord "task_to_note" memConn taskToNote1
      insertRecord "task_to_note" memConn taskToNote2

      cliOutput <- listNotes defaultConfig memConn

      show cliOutput `shouldContain` note1Id
      show cliOutput `shouldContain` note2Id

      let
        posUlid1 = subIndex note1Id (show cliOutput)
        posUlid2 = subIndex note2Id (show cliOutput)

      --  Newer notes should be listed first
      (posUlid2 < posUlid1) `shouldBe` True

  it "lets you delete a note" $ do
    withMemoryDb defaultConfig $ \memConn -> do
      insertRecord "tasks" memConn task1
      let noteId = "01hwcqk9nnwjypzw9kr646nqce"
      insertRecord
        "task_to_note"
        memConn
        TaskToNote
          { TaskToNote.ulid = noteId
          , TaskToNote.task_ulid = task1.ulid
          , TaskToNote.note = "The note content"
          }

      cliOutput <- deleteNote defaultConfig memConn noteId

      (show cliOutput :: Text)
        `shouldBe` "\128165 Deleted note \"01hwcqk9nnwjypzw9kr646nqce\" \
                   \of task \"01hs68z7mdg4ktpxbv0yfafznq\""