// socket_echo_debug.wren - Debug why echo test fails
import "socket" for Socket, SocketInstance

foreign class Host {
  foreign static signalDone()
}

var mainFiber = Fiber.new {
  System.print("=== Debug Echo Test ===\n")
  
  // Create and setup server
  System.print("1. Creating server socket...")
  var serverResult = SocketInstance.new()
  if (!serverResult || serverResult[0]) {
    System.print("  ERROR: Failed to create server socket")
    Host.signalDone()
    while(true) { Fiber.yield() }
  }
  var serverSock = serverResult[1]
  System.print("  ✓ Server socket created")
  
  System.print("\n2. Binding to port 30000...")
  var bindResult = serverSock.bind("127.0.0.1", 30000)
  if (bindResult[0]) {
    System.print("  ERROR: Bind failed: %(bindResult[0])")
    serverSock.close()
    Host.signalDone()
    while(true) { Fiber.yield() }
  }
  System.print("  ✓ Bound successfully")
  
  System.print("\n3. Starting listen...")
  var listenResult = serverSock.listen(5)
  if (listenResult[0]) {
    System.print("  ERROR: Listen failed: %(listenResult[0])")
    serverSock.close()
    Host.signalDone()
    while(true) { Fiber.yield() }
  }
  System.print("  ✓ Listening")
  
  var serverDone = false
  var serverAccepted = false
  var serverMessages = 0
  
  // Server fiber - with detailed logging
  var serverFiber = Fiber.new {
    System.print("\n[SERVER] Starting accept loop...")
    var acceptAttempts = 0
    var maxAttempts = 1000
    
    while (acceptAttempts < maxAttempts && !serverAccepted) {
      acceptAttempts = acceptAttempts + 1
      
      if (acceptAttempts % 100 == 0) {
        System.print("[SERVER] Accept attempt %(acceptAttempts)...")
      }
      
      var acceptResult = serverSock.accept()
      
      if (acceptResult) {
        if (acceptResult[0]) {
          // Only print non-"would block" errors
          var errStr = acceptResult[0]
          var isWouldBlock = false
          if (errStr.count > 5) {
            // Check for common "would block" messages
            if (errStr.indexOf("block") >= 0 || errStr.indexOf("Would") >= 0) {
              isWouldBlock = true
            }
          }
          if (!isWouldBlock) {
            System.print("[SERVER] Accept error: %(acceptResult[0])")
          }
        } else if (acceptResult[1]) {
          System.print("[SERVER] ✓ Connection accepted! fd=%(acceptResult[1])")
          serverAccepted = true
          
          var clientSock = SocketInstance.fromFd(acceptResult[1])
          System.print("[SERVER] Created client socket wrapper")
          
          // Echo loop
          var readAttempts = 0
          var maxReads = 500
          
          System.print("[SERVER] Starting read loop...")
          while (readAttempts < maxReads && serverMessages < 5) {
            readAttempts = readAttempts + 1
            
            if (readAttempts % 50 == 0) {
              System.print("[SERVER] Read attempt %(readAttempts)...")
            }
            
            var readResult = clientSock.read(1024)
            
            if (readResult) {
              if (readResult[0]) {
                var errStr = readResult[0]
                var isWouldBlock = false
                if (errStr && errStr.count > 5) {
                  if (errStr.indexOf("block") >= 0 || errStr.indexOf("Would") >= 0) {
                    isWouldBlock = true
                  }
                }
                if (!isWouldBlock) {
                  System.print("[SERVER] Read error: %(readResult[0])")
                }
              } else if (readResult[1] && readResult[1].count > 0) {
                serverMessages = serverMessages + 1
                System.print("[SERVER] ✓ Received message #%(serverMessages): %(readResult[1].count) bytes")
                
                // Echo back
                var writeErr = clientSock.write(readResult[1])
                if (writeErr) {
                  System.print("[SERVER] Write error: %(writeErr)")
                } else {
                  System.print("[SERVER] ✓ Echoed back %(readResult[1].count) bytes")
                }
              }
            }
            
            Fiber.yield()
          }
          
          System.print("[SERVER] Read loop ended after %(readAttempts) attempts")
          System.print("[SERVER] Messages processed: %(serverMessages)")
          
          clientSock.close()
          System.print("[SERVER] Client socket closed")
          break
        }
      }
      
      Fiber.yield()
    }
    
    if (!serverAccepted) {
      System.print("[SERVER] Never accepted connection after %(acceptAttempts) attempts")
    }
    
    System.print("[SERVER] Done")
    serverDone = true
  }
  
  var clientDone = false
  var clientMessages = 0
  
  // Client fiber - with detailed logging
  var clientFiber = Fiber.new {
    System.print("\n[CLIENT] Waiting for server to be ready...")
    for (i in 1..50) {
      Fiber.yield()
    }
    
    System.print("[CLIENT] Attempting to connect to 127.0.0.1:30000...")
    var connectResult = SocketInstance.connect("127.0.0.1", 30000)
    
    if (!connectResult) {
      System.print("[CLIENT] ERROR: Connect returned null")
      clientDone = true
      return
    }
    
    if (connectResult[0]) {
      System.print("[CLIENT] ERROR: Connect failed: %(connectResult[0])")
      clientDone = true
      return
    }
    
    var clientSock = connectResult[1]
    System.print("[CLIENT] ✓ Connected successfully")
    
    // Send 5 test messages
    for (i in 1..5) {
      var message = "Test message #%(i)"
      System.print("[CLIENT] Sending: %(message)")
      
      var writeErr = clientSock.write(message)
      if (writeErr) {
        System.print("[CLIENT] Write error: %(writeErr)")
        break
      } else {
        System.print("[CLIENT] ✓ Sent successfully")
        clientMessages = clientMessages + 1
        
        // Wait for echo
        var gotEcho = false
        var echoAttempts = 0
        
        System.print("[CLIENT] Waiting for echo...")
        while (echoAttempts < 100 && !gotEcho) {
          echoAttempts = echoAttempts + 1
          
          var readResult = clientSock.read(1024)
          if (readResult) {
            if (!readResult[0] && readResult[1] && readResult[1].count > 0) {
              System.print("[CLIENT] ✓ Received echo: %(readResult[1])")
              gotEcho = true
            }
          }
          
          if (echoAttempts % 20 == 0) {
            System.print("[CLIENT] Still waiting for echo... (attempt %(echoAttempts))")
          }
          
          Fiber.yield()
        }
        
        if (!gotEcho) {
          System.print("[CLIENT] WARNING: No echo received after %(echoAttempts) attempts")
        }
      }
      
      // Small delay between messages
      for (j in 1..10) Fiber.yield()
    }
    
    System.print("[CLIENT] Sent %(clientMessages) messages")
    
    clientSock.close()
    System.print("[CLIENT] Socket closed")
    System.print("[CLIENT] Done")
    clientDone = true
  }
  
  // Start both fibers
  System.print("\n4. Starting server and client fibers...")
  serverFiber.call()
  clientFiber.call()
  
  // Run event loop with monitoring
  var iterations = 0
  var maxIterations = 2000
  var lastPrint = 0
  
  while ((!serverDone || !clientDone) && iterations < maxIterations) {
    if (!serverDone) serverFiber.call()
    if (!clientDone) clientFiber.call()
    
    iterations = iterations + 1
    
    if (iterations - lastPrint >= 100) {
      System.print("\n[MAIN] Iteration %(iterations): server=%(serverDone ? "done" : "running"), client=%(clientDone ? "done" : "running")")
      lastPrint = iterations
    }
    
    Fiber.yield()
  }
  
  System.print("\n=== Test Complete ===")
  System.print("Total iterations: %(iterations)")
  System.print("Server accepted: %(serverAccepted)")
  System.print("Server messages: %(serverMessages)")
  System.print("Client messages: %(clientMessages)")
  
  serverSock.close()
  
  Host.signalDone()
  while(true) { Fiber.yield() }
}