10 + 20

// Access object properies with .
// Access string and array elements with []

let data = {
  numbers: [1, 2, 3],
  chars: ["a", "b", "c"],
  string: "Albert"
};

write!(data.numbers[0]);
write!(data.chars[2]);
write!(data.string[0]);

write!({a: 1, b: 2, c: 3}.b);
write!("Albert"[3]);
write!([1, 2, 3][2]);

plus(x, y)

// Functional Text Adventure Game in Lits

// Define locations
let locations = {
  forest: {
    description: "You are in a dense forest. Light filters through the leaves above.",
    exits: { north: "cave", east: "river", south: "meadow" }
  },
  cave: {
    description: "You stand in a dark cave. Water drips from stalactites overhead.",
    exits: { south: "forest", east: "tunnel" },
    items: ["torch"]
  },
  river: {
    description: "A swift river flows from the mountains. The water is crystal clear.",
    exits: { west: "forest", north: "waterfall" },
    items: ["fishing rod"]
  },
  meadow: {
    description: "A peaceful meadow stretches before you, filled with wildflowers.",
    exits: { north: "forest", east: "cottage" },
    items: ["flowers"]
  },
  waterfall: {
    description: "A magnificent waterfall cascades down from high cliffs.",
    exits: { south: "river" },
    items: ["shiny stone"]
  },
  tunnel: {
    description: "A narrow tunnel leads deeper into the mountain.",
    exits: { west: "cave", east: "treasure room" }
  },
  "treasure room": {
    description: "A small chamber glittering with treasure!",
    exits: { west: "tunnel" },
    items: ["gold key", "ancient map", "jeweled crown"]
  },
  cottage: {
    description: "A cozy cottage with a smoking chimney stands here.",
    exits: { west: "meadow" },
    items: ["bread"]
  }
};

// Define game state
let initial-state = {
  current-location: "forest",
  inventory: [],
  visited: {},
  game-over: false,
  moves: 0,
  light-source: false
};

// Helper functions
function has-item?(state, item) {
  contains?(state.inventory, item);
};

function location-has-item?(location, item) {
  contains?(get(location, "items", []), item);
};

function describe-location(state) {
  let location = get(locations, state.current-location);
  let description = location.description;

  // Add visited status
  let visited-status = if (get(state.visited, state.current-location, 0) > 1) {
    "You've been here before."
  } else {
    "This is your first time here."
  };

  // Check if location has items
  let items-desc = if (!(empty?(get(location, "items", [])))) {
    "You see: " ++ join(location.items, ", ")
  } else {
    ""
  };

  // Describe exits
  let exits = keys(location.exits) join ", ";
  let exits-desc = "Exits: " ++ exits;

  // Join all descriptions
  filter([description, visited-status, items-desc, exits-desc], -> !(empty?($))) join "\n"
};

function get-location-items(state) {
  let location = get(locations, state.current-location);
  get(location, "items", [])
};

// Game actions
function move(state, direction) {
  let location = get(locations, state.current-location);
  let exits = get(location, "exits", {});

  // Check if direction is valid
  if (contains?(exits, direction)) {
    let new-location = get(exits, direction);
    let is-dark = new-location == "tunnel" || new-location == "treasure room";

    // Check if player has light source for dark areas
    if (is-dark && !(state.light-source)) {
      [state, "It's too dark to go that way without a light source."]
    } else {
      let new-visited = assoc(
        state.visited,
        new-location,
        inc(state.visited["new-location"] ?? 0)
      );
      let new-state = assoc(
        assoc(
          assoc(state, "current-location", new-location),
          "visited",
          new-visited
        ),
        "moves",
        state.moves + 1
      );

      [new-state, "You move " ++ direction ++ " to the " ++ new-location ++ "."]
    }
  } else {
    [state, "You can't go that way."]
  }
};

function take!(state, item) {
  let items = get-location-items(state);

  if (contains?(items, item)) {
    let location = get(locations, state.current-location);
    let new-location-items = filter(items, -> $ ≠ item);
    let new-inventory = push(state.inventory, item);

    // Update game state
    let new-locations = assoc(
      locations, 
      state.current-location,
      assoc(location, "items", new-location-items)
    );

    // Special case for torch
    let has-light = item == "torch" || state.light-source;

    // Update locations and state
    let locations = new-locations;
    let new-state = assoc(
      assoc(
        assoc(state, "inventory", new-inventory),
        "light-source", has-light
      ),
      "moves",
      state.moves + 1
    );
    [new-state, "You take the " ++ item ++ "."]
  } else {
    [state, "There is no " ++ item ++ " here."]
  }
};

function drop!(state, item) {
  if (has-item?(state, item)) {
    let location = get(locations, state.current-location);
    let location-items = get(location, "items", []);
    let new-location-items = push(location-items, item);
    let new-inventory = filter(-> $ ≠ item, state.inventory);

    // Special case for torch
    let still-has-light = !(item == "torch") || contains?(new-inventory, "torch");

    // Update locations and state
    let new-location = assoc(location, "items", new-location-items);
    let locations = assoc(locations, state.current-location, new-location);

    let new-state = assoc(
      assoc(
        assoc(
          state, "inventory", new-inventory),
          "light-source",
          still-has-light
        ),
        "moves",
        state.moves + 1
      );
    [new-state, "You drop the " ++ item ++ "."]
  } else {
    [state, "You don't have a " ++ item ++ " in your inventory."]
  }
};

function inventory(state) {
  if (empty?(state.inventory)) {
    [state, "Your inventory is empty."]
  } else {
    [state, "Inventory: " ++ join(state.inventory, ", ")]
  }
};

function use(state, item) {
  switch (item) {
    case "fishing rod":
      if (state.current-location == "river") {
        [assoc(state, "moves", state.moves + 1), "You catch a small fish, but it slips away."]
      } else {
        [state, "There's no place to use a fishing rod here."]
      }
    case "torch":
      if (has-item?(state, item)) {
        [
          assoc(assoc(state, "light-source", true), "moves", state.moves + 1),
          "The torch illuminates the area with a warm glow."
        ]
      } else {
        [state, "You don't have a torch."]
      }
    case "gold key":
      if (has-item?(state, item) && state.current-location == "treasure room") {
        [
          assoc(
            assoc(state, "game-over", true),
            "moves",
            state.moves + 1
          ),
         "You use the gold key to unlock a secret compartment, revealing a fabulous diamond! You win!"
        ]
      } else {
        [state, "The key doesn't fit anything here."]
      }
    case "bread":
      if (has-item?(state, item)) {
        let new-inventory = filter(state.inventory, -> $ ≠ item);
        [
          assoc(
            assoc(state, "inventory", new-inventory),
            "moves",
            state.moves + 1
          ),
          "You eat the bread. It's delicious and nourishing."
        ]
      } else {
        [state, "You don't have any bread."]
      }
    case "shiny stone":
      if (has-item?(state, item)) {
        [
          assoc(state, "moves", state.moves + 1),
          "The stone glows with a faint blue light. It seems magical but you're not sure how to use it yet."
        ]
      } else {
        [state, "You don't have a shiny stone."]
      }
    case "flowers":
      if (has-item?(state, item)) {
        [
          assoc(state, "moves", state.moves + 1),
          "You smell the flowers. They have a sweet, calming fragrance."
        ]
      } else {
        [state, "You don't have any flowers."]
      }
    case "ancient map":
      if (has-item?(state, item)) {
        [
          assoc(state, "moves", state.moves + 1),
          "The map shows the layout of the area. All locations are now marked as visited."
        ]
      } else {
        [state, "You don't have a map."]
      }
    case "jeweled crown":
      if (has-item?(state, item)) {
        [
          assoc(state, "moves", state.moves + 1),
          "You place the crown on your head. You feel very regal."
        ]
      } else {
        [state, "You don't have a crown."]
      }
  } ?? [state, "You can't use that."]
};

// Command parser
function parse-command(state, input) {
  let tokens = lower-case(input) split " ";
  let command = first(tokens);
  let args = rest(tokens) join " ";

  let result = switch (command) {
    case "go":
      move(state, args)
    case "north":
      move(state, "north")
    case "south":
      move(state, "south")
    case "east":
      move(state, "east")
    case "west":
      move(state, "west")
    case "take":
      take!(state, args)
    case "drop":
      drop!(state, args)
    case "inventory":
      inventory(state)
    case "i":
      inventory(state)
    case "look":
      [assoc(state, "moves", state.moves + 1), describe-location(state)]
    case "use":
      use(state, args)
    case "help":
      [state, "Commands: go [direction], north, south, east, west, take [item], drop [item], inventory, look, use [item], help, quit"]
    case "quit":
      [assoc(state, "game-over", true), "Thanks for playing!"]
  } ?? [state, "I don't understand that command. Type 'help' for a list of commands."];

  result
};

// Game loop
function game-loop(state) {
  alert!(describe-location(state) ++ "\nWhat do you do? ");

  let input = read-line!();
  let command_result = parse-command(state, input);
  let new-state = first(command_result);
  let message = second(command_result);

  alert!("\n" ++ message ++ "\n");

  if (new-state.game-over) {
    alert!("\nGame over! You made " ++ str(new-state.moves) ++ " moves.");
    new-state
  } else {
    game-loop(new-state)
  }
};

// Start game
function start-game() {
  alert!("=== Lits Adventure Game ===\n" ++ "Type 'help' for a list of commands.\n\n");
  game-loop(initial-state)
};

// Call the function to start the game
start-game()

// Determinant function for square matrices
function determinant(matrix) {
  // Check if input is an array
  unless (array?(matrix)) {
    throw("Input must be an array");
  };

  // Check if matrix is empty
  if (empty?(matrix)) {
    throw("Matrix cannot be empty");
  };

  let rows = count(matrix);
  
  // Get first row to check column count
  let firstRow = first(matrix);
  
  // Check if first row is an array
  unless (array?(firstRow)) {
    throw("Input must be a 2D array");
  };
  
  let cols = count(firstRow);
  
  // Ensure matrix is square
  if (rows ≠ cols) {
    throw("Matrix must be square");
  };
  
  // Base case: 1x1 matrix
  if (rows == 1) {
    matrix[0][0];
  } else {
    // Base case: 2x2 matrix
    if (rows == 2) {
      let a = matrix[0][0];
      let b = matrix[0][1];
      let c = matrix[1][0];
      let d = matrix[1][1];
      
      a * d - b * c;
    } else {
      // For larger matrices, use cofactor expansion along first row
      // Use reduce to calculate the determinant without mutating variables
      reduce(
        range(cols),
        (acc, j) -> {
          let minor = getMinor(matrix, 0, j);
          let cofactor = determinant(minor);
          let signFactor = even?(j) ? 1 : -1;
          let term = signFactor * matrix[0][j] * cofactor;
          
          acc + term;
        },
        0,
      );
    }
  }
};

// Helper function to get minor (submatrix) by removing specific row and column
function getMinor(matrix, rowToRemove, colToRemove) {
  // Use map with filter to create the new matrix without mutating
  map(
    range(count(matrix)),
    i -> {
      if (i == rowToRemove) {
        null; // This will be filtered out
      } else {
        let row = get(matrix, i);
        // Filter out the column to remove
        map(
          range(count(row)),
          j -> {
            if (j == colToRemove) {
              null; // This will be filtered out
            } else {
              get(row, j)
            }
          }
        ) filter (item -> item ≠ null);
      }
    }
  ) filter (row -> row ≠ null);
};
  
// 4x4 invertible matrix
let matrix4x4 = [
  [4,  3,  2,  2],
  [0,  1, -3,  3],
  [0, -1,  3,  3],
  [0,  3,  1,  1]
];
determinant(matrix4x4);

// Matrix multiplication with correct syntax
function matrixMultiply(matrixA, matrixB) {
  // Check if inputs are arrays
  unless (array?(matrixA)) throw("First input must be an array");
  unless (array?(matrixB)) throw("Second input must be an array");

  // Check if matrices are not empty
  if (empty?(matrixA) || empty?(matrixB)) throw("Matrices cannot be empty");

  // Check if matrices are 2D arrays
  unless (array?(first(matrixA))) throw("First input must be a 2D array");
  unless (array?(first(matrixB))) throw("Second input must be a 2D array");

  // Get dimensions
  let rowsA = count(matrixA);
  let colsA = count(first(matrixA));
  let rowsB = count(matrixB);
  let colsB = count(first(matrixB));

  // Check if all rows have consistent length
  unless (every?(matrixA, row -> array?(row) && count(row) == colsA)) {
    throw("First matrix has inconsistent row lengths")
  };
  
  unless (every?(matrixB, row -> array?(row) && count(row) == colsB)) {
    throw("Second matrix has inconsistent row lengths")
  };

  // Check if matrices can be multiplied
  unless (colsA == rowsB) {
    throw("Matrix dimensions mismatch: first matrix columns must equal second matrix rows");
  };

  // Create a row of the result matrix
  function createRow(rowIndex) {
    for (j in range(colsB)) {
      reduce(
        range(colsA),
        (sum, k) -> {
          let aValue = matrixA[rowIndex][k];
          let bValue = matrixB[k][j];
          sum + (aValue * bValue);
        },
        0
      )
    }
  };

  // Create the result matrix row by row
  for (i in range(rowsA)) {
    createRow(i);
  }
};

let matrixA = [
  [1, 2, 3],
  [4, 5, 6]
];

let matrixB = [
  [7, 8],
  [9, 10],
  [11, 12]
];

matrixMultiply(matrixA, matrixB);

function formatPhoneNumber(data) {
  if (string?(data)) {
    let phoneNumber = data[0] == "+" ? data slice 2 : data;
    let length = count(phoneNumber);

    cond {
      case length > 6:
        "(" ++ slice(phoneNumber, 0, 3) ++ ") " ++ slice(phoneNumber, 3, 6) ++ "-" ++ slice(phoneNumber, 6)
      case length > 3:
        "(" ++ slice(phoneNumber, 0, 3) ++ ") " ++ slice(phoneNumber, 3)
      case length > 0:
        "(" ++ slice(phoneNumber, 0)
    } ?? ""
  } else {
    ""
  }
};


write!(formatPhoneNumber);
write!(formatPhoneNumber(123234));
write!(formatPhoneNumber("123234"));
write!(formatPhoneNumber("1232343456"));
write!(formatPhoneNumber("+11232343456789"));
write!(formatPhoneNumber("+11232343456"));

function factorial(x) {
  if (x == 1) {
    1
  } else {
    x * factorial(x - 1)
  }
};

factorial(5)

let l = [7, 39, 45, 0, 23, 1, 50, 100, 12, -5];
function numberComparer(a, b) {
  cond {
    case a < b: -1
    case a > b: 1
  } ?? 0
};

sort(l, numberComparer)

function isoDateString?(data) {
  let m = data match #"^(\d{4})-(\d{2})-(\d{2})$";

  if (m) {
    let [year, month, day] = slice(m, 1) map number;
    let leapYear = zero?(year mod 4) && (!zero?(year mod 100) || zero?(year mod 400));

    let invalid = 
      (year < 1900 || year > 2100)
      || (month < 1 || month > 12)
      || (day < 1 || day > 31)
      || day > 30 && (month == 4 || month == 6 || month == 9 || month == 11)
      || month == 2 && (leapYear && day > 29 || !leapYear && day > 28);

    !(invalid)
  } else {
    false
  }
};

write!(isoDateString?("1978-12-21"));
write!(isoDateString?("197-12-21"));

function label-from-value(items, value) {
  let entry = items some (-> value == $["value"]);
  if (entry == null) {
    null
  } else {
    entry["label"]
  }
};


let items = [
  { label: "Name", value: "name" },
  { label: "Age", value: "age" }
];

label-from-value(items, "name");

function labels-from-values($array, $values) {
  for (value in $values,
      let label = {
        let entry = $array some -> value == $["value"];
        if (entry == null) {
          value
        } else {
          entry["label"]
        }
      }
  ) {
    label
  }
};

let arr = [
  { label: "Name", value: "name" },
  { label: "Age", value: "age" },
  { label: "Email", value: "email" },
];

labels-from-values(arr, ["name", "age"])