#!/usr/bin/env runhaskell
import System.Environment (getArgs)
import System.Exit (exitSuccess)
import Control.Monad (forever, when)
-- la siguiente linea requiere incluir la biblioteca random-fu al ambiente donde se ejecute el script
-- eso se puede lograr con cabal build random-fu
import Data.Random (sample, randomElement)

-- forever hace que el programa nos vuelva a preguntar en vez de terminar luego de una respuesta
main = forever $ do
   -- leemos los argumentos que le pasan al programa
   rutaARespuestas <- head <$> getArgs
   respuestas <- lines <$> readFile rutaARespuestas

   -- usamos stdout para mostrar cosas por la consola
   putStrLn "Preguntá algo:"
   putStr "> "

   -- y usamos stdin para leer la entrada
   pregunta <- getLine

   -- cuando la pregunta es el string "salir" cerramos el programa
   when (pregunta == "salir") $ do
       putStrLn "Hasta Luego!"
       exitSuccess
      
   respuesta <- sample $ randomElement respuestas
   putStrLn respuesta
        

            
#!/usr/bin/env -S java --source 11
// el parámetro -S es para poder pasar parámetros a java, y --source se lo estamos pasando para decir que
// ejecute esto como java 11

// Para que el interprete de java ignore la línea con el #!, el archivo NO tiene que terminar en .java
import java.nio.file.Files;
import java.nio.charset.Charset;
import java.util.List;
import java.nio.file.Paths;
import java.io.IOException;
import java.util.Random;
import java.util.Scanner;

// Al ejecutar un script de java, se va a usar el main de la primer clase que se encuentre
public class BolaMagica {
   public static void main(String[] args) throws IOException {
       // leemos los argumentos que le pasan al programa
       String rutaALasRespuestas = args[0];
       List<String> respuestas = Files.readAllLines(Paths.get(rutaALasRespuestas), Charset.defaultCharset());
       Scanner scanner = new Scanner(System.in);
       Random random = new Random();

       // el while True es para que el programa nos vuelva a preguntar en vez de terminar
       while(true) {
           // usamos stdout para mostrar cosas por la consola
           System.out.println("Preguntá algo:");
           System.out.print("> ");

           // y usamos stdin para leer la entrada
           String pregunta = scanner.nextLine();
           // agregamos una forma de salir del while para terminar el programa
           if(pregunta.equals("salir")) {
               System.out.println("Hasta luego!");
               break;
           }

           String respuesta = respuestas.get(random.nextInt(respuestas.size()));
           System.out.println(respuesta);
       }
   }
}



        

            #!/usr/bin/env node
const fs = require('fs');
const readline = require('readline');

// leemos los argumentos del programa, recién a partir del tercero son los que se pasan como parámetro
const rutaALasRespuestas = process.argv[2];
const respuestas = fs.readFileSync(rutaALasRespuestas, 'utf-8').split('\n').filter(linea => linea.length != "");

const obtenerRespuesta = () => respuestas[Math.floor(Math.random() * respuestas.length)];

const rl = readline.createInterface({
   input: process.stdin,
   output: process.stdout
 });


// Como en node leer el input del usuario es una operación asincrónica,
// vamos a encararlo de forma diferente a como hicimos en los otros scripts.
// Usamos recursividad para que tras cada respuesta se vuelva a empezar
const preguntarYResponder = () => {
   // usamos stdout para mostrar cosas por la consola
   console.log("Preguntá algo:");
   // y usamos stdin para leer la entrada
   rl.question("> ", respuesta => {
       // agregamos una forma de cortar la recursividad
       if(respuesta == "salir") {
           console.log("Hasta luego!");
           rl.close();
       } else {
           console.log(obtenerRespuesta());
           // si no vino "salir", llamamos de nuevo a la función recursivamente
           preguntarYResponder();
       }
   })
}

// Lo de arriba fue la definición de la función, hay que llamarla
// una vez para que empiece el programa
preguntarYResponder();

        

            #!/usr/bin/env -S kotlinc -script
// los scripts en kotlin se corren con kotlinc -script y tienen que terminar en .kts
import java.io.File

// leemos los argumentos que le pasan al programa
val rutaALasRespuestas = args[0]
val respuestas = File(rutaALasRespuestas).readLines()

// el while True es para que el programa nos vuelva a preguntar en vez de terminar
while(true) {
   // usamos stdout para mostrar cosas por la consola
   println("Preguntá algo:")
   print("> ")

   // Esta linea es necesaria porque si no el "> " no se iba a imprimir
   // por pantalla hasta despues de pedir input al usuario :(
   System.out.flush()
  
   // y usamos stdin para leer la entrada
   val pregunta = readLine()
   // agregamos una forma de salir del while para terminar el programa
   if(pregunta == "salir") {
       println("Hasta luego!")
       break
   }

   val respuesta = respuestas.random()
   println(respuesta)
}
        

            #!/usr/bin/env python
import sys
import random

# leemos los argumentos que le pasan al programa
archivo_de_respuestas = open(sys.argv[1])
respuestas = archivo_de_respuestas.readlines()
archivo_de_respuestas.close()

# el while True es para que el programa nos vuelva a preguntar en vez de terminar
while True:
   # usamos stdout para mostrar cosas por la consola
   print("Preguntá algo:")

   # y usamos stdin para leer la entrada
   pregunta = input(">")

   # agregamos una forma de salir del while para terminar el programa
   if(pregunta == "salir"):
       print("Hasta luego!")
       break

   respuesta = random.choice(respuestas)
   print(respuesta)

        

            #!/usr/bin/env ruby
ruta_a_respuestas = ARGV[0] # leemos los argumentos que le pasan al programa
respuestas = File.readlines ruta_a_respuestas

# el while True es para que el programa nos vuelva a preguntar en vez de terminar
while true
   # usamos stdout para mostrar cosas por la consola
   puts "Preguntá algo:"
   print "> "

   # y usamos stdin para leer la entrada
   pregunta = $stdin.gets.chomp

   # agregamos una forma de salir del while para terminar el programa
   if pregunta == "salir"
       puts "Hasta luego!"
       break
   end

   respuesta = respuestas.sample
   puts respuesta
end