package main

import (
 "fmt"
 "math"
 "os"
 "strconv"
 "strings"
)

func main() {
 dat, err := os.ReadFile("./input.txt")
 
 if err != nil {
  fmt.Println("Couldn't read input", err.Error())
 }

 reports, err := parseReports(dat)

 if err != nil {
  fmt.Println("Couldn't parse repoorts", err.Error())
 }

 safeReports := 0

 for i := 0; i < len(reports); i++ {
  levels := reports[i]
  isInitiallyIncreasing := levels[0] > levels[1]
  isReportSafe := true
  
  for j := 1; j < len(levels); j++ {
   previousLevel := levels[j - 1]
   currentLevel := levels[j]

   isIncreasing := previousLevel > currentLevel
   if isInitiallyIncreasing != isIncreasing {
    isReportSafe = false
    break
   }

   difference := math.Abs(previousLevel - currentLevel)
   if !(difference >= 1 && difference <= 3) {
    isReportSafe = false
    break
   }
  }

  if isReportSafe {
   safeReports++
  }
 }

 fmt.Println("There are", safeReports, "safe reports")
}

func parseReports(inp []byte) ([][]float64, error) {
 reports := strings.Split(string(inp), "\n")
 var parsedReports [][]float64

 for i := 0; i < len(reports); i++ {
  report := reports[i]
  levels := strings.Fields(report)
  var parsedLevels []float64

  for j := 0; j < len(levels); j++ {
   parsedLevel, err := strconv.ParseFloat(levels[j], 64)

   if err != nil {
    return nil, err
   }

   parsedLevels = append(parsedLevels, parsedLevel)
  }

  parsedReports = append(parsedReports, parsedLevels)
 }

 return parsedReports, nil
}

rm -rf node_modules

brew install trash

trash node_modules