path: root/Sources/swift-gopher/gopherHandler.swift

import ArgumentParser
import Foundation
import GopherHelpers
import Logging
import NIO

final class GopherHandler: ChannelInboundHandler {
  typealias InboundIn = ByteBuffer
  typealias OutboundOut = ByteBuffer

  let gopherdata_dir: String
  let gopherdata_host: String
  let gopherdata_port: Int
  let logger: Logger
  let enableSearch: Bool
  let disableGophermap: Bool

  init(
    logger: Logger,
    gopherdata_dir: String = "./example-gopherdata", gopherdata_host: String = "localhost",
    gopherdata_port: Int = 70, enableSearch: Bool = false,
    disableGophermap: Bool = false
  ) {
    self.gopherdata_dir = gopherdata_dir
    self.gopherdata_host = gopherdata_host
    self.gopherdata_port = gopherdata_port
    self.logger = logger
    self.enableSearch = enableSearch
    self.disableGophermap = disableGophermap
  }

  private var buffer = ByteBuffer()
  let delChar = Character(UnicodeScalar(127))
  let backspaceChar = Character(UnicodeScalar(8))

  func channelRead(context: ChannelHandlerContext, data: NIOAny) {
    var input = self.unwrapInboundIn(data)
    buffer.writeBuffer(&input)

    //    print(buffer.readableBytes)

    if let requestString = buffer.getString(at: 0, length: buffer.readableBytes) {
      if requestString.firstIndex(of: "\r\n") != nil || requestString.firstIndex(of: "\n") != nil
        || requestString.firstIndex(of: "\r") != nil
      {  // May not be necessary to use last two cases
        if let remoteAddress = context.remoteAddress {
          logger.info(
            "Received request from \(remoteAddress) for '\(requestString.replacingOccurrences(of: "\r\n", with: "<GopherSequence>").replacingOccurrences(of: "\n", with: "<Linebreak>"))'"
          )
        } else {
          logger.warning("Unable to retrieve remote address")
        }

        var processedRequestString: String = requestString.replacingOccurrences(
          of: "\r\0", with: "")
        // Check for backspace or delete and process them
        if processedRequestString.contains(delChar)
          || processedRequestString.contains(backspaceChar)
        {
          logger.info(
            "Request contains delete character (ASCII code 127) or the backsapce character (ASCII code 8), processing delete sequences"
          )

          func processDeleteCharacter(_ input: String, _ asciiCode: Int = 8) -> String {
            var result: [Character] = []
            for character in input {
              if let asciiValue = character.asciiValue, asciiValue == asciiCode {
                if !result.isEmpty {
                  result.removeLast()
                }
              } else {
                result.append(character)
              }
            }
            return String(result)
          }

          processedRequestString = processDeleteCharacter(requestString, 127)
          processedRequestString = processDeleteCharacter(processedRequestString)  // Could just combine in one statement if asciiCode is changed to asciiCodes: [Int]
        }

//        for character in requestString {  // Helpful for debugging
//          if let scalar = character.unicodeScalars.first, scalar.value < 128 {
//            print("\(character): \(scalar.value)")
//          } else {
//            print("\(character): Not an ASCII character")
//          }
//        }

        let response = processGopherRequest(processedRequestString)
        var outputBuffer: ByteBuffer
        switch response {
        case .string(let string):
          outputBuffer = context.channel.allocator.buffer(string: string)
        case .data(let data):
          outputBuffer = context.channel.allocator.buffer(bytes: data)
        }

        context.writeAndFlush(self.wrapOutboundOut(outputBuffer)).whenComplete { _ in
          context.close(mode: .all, promise: nil)
        }

      } else {
        //print("No CR/LF")
      }
    }
  }

  func requestHandler(path: URL) -> ResponseType {
    logger.info("Handling request for '\(path.path)'")

    // Check if path is a directory or a file
    let fm = FileManager.default
    var isDir: ObjCBool = false

    if fm.fileExists(atPath: path.path, isDirectory: &isDir) {
      if isDir.boolValue {
        return .string(prepareGopherMenu(path: path))
      } else {
        // Check if file is plain text or binary
        let fileExtension = path.pathExtension
        let fileType = getFileType(fileExtension: fileExtension)

        if fileType == .text || fileType == .html {
          do {
            let fileContents = try String(contentsOfFile: path.path, encoding: .utf8)

            return .string(fileContents)
          } catch {
            logger.error("Error reading file: \(path.path) Error: \(error)")
            return .string("3Error reading file...\t\terror.host\t1\r\n")
          }
        } else {
          // Handle binary file
          do {
            let fileContents = try Data(contentsOf: path)
            return .data(fileContents)
          } catch {
            logger.error("Error reading binary file: \(path.path) Error: \(error)")
            return .string("3Error reading file...\t\terror.host\t1\r\n")
          }
        }

      }
    } else {
      logger.error("Error reading directory: \(path.path) Directory does not exist.")
      return .string("3Error reading file...\t\terror.host\t1\r\n")
    }

  }

  func preparePath(path: String = "/") -> URL {
    var sanitizedPath = sanitizeSelectorPath(path: path)
    let base_dir = URL(fileURLWithPath: gopherdata_dir)
    if base_dir.path.hasSuffix("/") && sanitizedPath.hasPrefix("/") {
      sanitizedPath = String(sanitizedPath.dropFirst())
    }

    // Now check if there is still a prefix
    if sanitizedPath.hasPrefix("/") {
      sanitizedPath = String(sanitizedPath.dropFirst())
    }

    let full_path = base_dir.appendingPathComponent(sanitizedPath)
    return full_path
  }

  func generateGopherItem(
    item_name: String, item_path: URL, item_host: String? = nil, item_port: String? = nil
  ) -> String {
    let myItemHost = item_host ?? gopherdata_host
    let myItemPort = item_port ?? String(gopherdata_port)
    let base_path = URL(fileURLWithPath: gopherdata_dir)
    var relative_path = item_path.path.replacingOccurrences(of: base_path.path, with: "")
    if !relative_path.hasPrefix("/") {
      relative_path = "/\(relative_path)"
    }
    return "\(item_name)\t\(relative_path)\t\(myItemHost)\t\(myItemPort)\r\n"
  }

  func generateGopherMap(path: URL) -> [String] {
    var items: [String] = []

    var basePath = URL(fileURLWithPath: gopherdata_dir).path
    if basePath.hasSuffix("/") {
      basePath = String(basePath.dropLast())
    }

    let fm = FileManager.default
    do {
      print("Reading directory: \(path.path)")
      let itemsInDirectory = try fm.contentsOfDirectory(at: path, includingPropertiesForKeys: nil)
      for item in itemsInDirectory {
        let isDirectory = try item.resourceValues(forKeys: [.isDirectoryKey]).isDirectory ?? false
        let name = item.lastPathComponent
        if isDirectory {
          items.append(generateGopherItem(item_name: "1\(name)", item_path: item))
        } else {
          let fileType = getFileType(fileExtension: item.pathExtension)
          let gopherFileType = fileTypeToGopherItem(fileType: fileType)
          items.append(generateGopherItem(item_name: "\(gopherFileType)\(name)", item_path: item))
        }
      }
    } catch {
      print("Error reading directory: \(path.path)")
    }
    return items
  }

  func prepareGopherMenu(path: URL = URL(string: "/")!) -> String {
    var gopherResponse: [String] = []

    let fm = FileManager.default

    do {
      let gophermap_path = path.appendingPathComponent("gophermap")
      if fm.fileExists(atPath: gophermap_path.path) && !disableGophermap {
        let gophermap_contents = try String(contentsOfFile: gophermap_path.path, encoding: .utf8)
        let gophermap_lines = gophermap_contents.components(separatedBy: "\n")
        for originalLine in gophermap_lines {
          // Only keep first 80 characters
          var line = String(originalLine)  //.prefix(80)
          if "0123456789+gIT:;<dhprsPXi".contains(line.prefix(1)) && line.count > 1 {
            if line.hasSuffix("\n") {
              line = String(line.dropLast())
            }
            if line.prefix(1) == "i" {
              gopherResponse.append("\(line)\t\terror.host\t1\r\n")
              continue
            }

            let regex = try! NSRegularExpression(pattern: "\\t+| {2,}")
            let nsString = line as NSString
            let range = NSRange(location: 0, length: nsString.length)
            let matches = regex.matches(in: String(line), range: range)

            var lastRangeEnd = 0
            var components = [String]()

            for match in matches {
              let range = NSRange(
                location: lastRangeEnd, length: match.range.location - lastRangeEnd)
              components.append(nsString.substring(with: range))
              lastRangeEnd = match.range.location + match.range.length
            }

            if lastRangeEnd < nsString.length {
              components.append(nsString.substring(from: lastRangeEnd))
            }

            if components.count < 3 {
              continue
            }

            let item_name = components[0]
            let item_path = components[1]
            let item_host = components[2]
            let item_port = components.count > 3 ? components[3] : "70"

            let item_line = "\(item_name)\t\(item_path)\t\(item_host)\t\(item_port)\r\n"
            gopherResponse.append(item_line)
          } else {
            line = line.replacingOccurrences(of: "\n", with: "")
            gopherResponse.append("i\(line)\t\terror.host\t1\r\n")
          }
        }
      } else {
        print("No gophermap found for \(path.path)")
        gopherResponse = generateGopherMap(path: path)
      }
    } catch {
      logger.error("Error reading directory: \(path.path)")
      gopherResponse.append("3Error reading directory...\r\n")
    }

    // Append Search
    if enableSearch {
      let search_line = "7Search Server\t/search\t\(gopherdata_host)\t\(gopherdata_port)\r\n"
      gopherResponse.append(search_line)
    }

    // Append Server Info
    gopherResponse.append(buildVersionStringResponse())

    return gopherResponse.joined(separator: "")
  }

  // TODO: Refactor
  func performSearch(query: String) -> String {
    // Really basic search implementation

    var search_results = [String: String]()

    let fm = FileManager.default

    let base_dir = URL(fileURLWithPath: gopherdata_dir)

    let enumerator = fm.enumerator(at: base_dir, includingPropertiesForKeys: nil)

    while let file = enumerator?.nextObject() as? URL {
      let file_name = file.lastPathComponent
      let file_path = file.path
      let file_type =
        try? file.resourceValues(forKeys: [.isDirectoryKey]).isDirectory ?? false ? "1" : "0"

      if file_type == "0" {
        // Check if file name or contents match the query
        let file_contents = try? String(contentsOfFile: file_path, encoding: .utf8)
        if file_name.lowercased().contains(query)
          || (file_contents?.lowercased().contains(query) ?? false)
        {
          search_results[file_name] = file_path
        }
      } else {
        // Check if directory name matches the query
        if file_name.lowercased().contains(query) {
          search_results[file_name] = file_path
        }
      }
    }

    // Prepare Gopher menu with search results
    var gopherResponse: [String] = []

    for (_, file_path) in search_results {
      var item_type =
        try? URL(fileURLWithPath: file_path).resourceValues(forKeys: [.isDirectoryKey]).isDirectory
        ?? false ? "1" : "0"
      if item_type == "0" {
        item_type = fileTypeToGopherItem(
          fileType: getFileType(fileExtension: URL(fileURLWithPath: file_path).pathExtension))
      }
      let item_host = gopherdata_host
      let item_port = gopherdata_port
      let item_path = file_path.replacingOccurrences(of: base_dir.path, with: "")
      let item_line =
        "\(item_type ?? "0")\(item_path)\t\(item_path)\t\(item_host)\t\(item_port)\r\n"
      gopherResponse.append(item_line)
    }

    if gopherResponse.count == 0 {
      gopherResponse.append("iNo results found for the query \(query)\r\n")
    }
    gopherResponse.append(buildVersionStringResponse())
    return gopherResponse.joined(separator: "")

  }

  func sanitizeSelectorPath(path: String) -> String {
    // Replace \r\n with empty string
    var sanitizedRequest = path.replacingOccurrences(of: "\r\n", with: "")

    // Basic escape against directory traversal
    while sanitizedRequest.contains("..") {
      sanitizedRequest = sanitizedRequest.replacingOccurrences(of: "..", with: "")
    }

    while sanitizedRequest.contains("//") {
      sanitizedRequest = sanitizedRequest.replacingOccurrences(of: "//", with: "/")
    }

    return sanitizedRequest
  }

  func channelReadComplete(context: ChannelHandlerContext) {
    context.flush()
  }

  func errorCaught(context: ChannelHandlerContext, error: Error) {
    print("Error: \(error)")
    logger.error("Error: \(error)")
    context.close(promise: nil)
  }

  private func processGopherRequest(_ originalRequest: String) -> ResponseType {
    var request = originalRequest

    // Fix for "Gopher" (iOS) client sending an extra \n
    if request.hasSuffix("\n\n") {
      request = String(request.dropLast())
    }

    if request == "\r\n" {  // Empty request
      return .string(prepareGopherMenu(path: preparePath()))
    }

    // Check if request is an HTTP url
    if request.hasPrefix("URL:") {
      let url = String(request.dropFirst(4))
      return .string(
        "<!DOCTYPE html><html><head><meta http-equiv=\"refresh\" content=\"0; url=\(url)\" /></head><body></body></html>"
      )
    }

    // Again, fix for the iOS client. Might as well make my own client
    if request.hasSuffix("\n") {
      request = String(request.dropLast())
    }

    if request.contains("\t") {
      if enableSearch {
        var searchQuery = request.components(separatedBy: "\t")[1]
        searchQuery = searchQuery.replacingOccurrences(of: "\r\n", with: "")
        return .string(performSearch(query: searchQuery.lowercased()))
      } else {
        return .string("3Search is disabled on this server.\r\n")
      }
    }

    //TODO: Potential Bug in Gopher implementation? curl gopher://localhost:8080/new_folder/ does not work but curl gopher://localhost:8080//new_folder/ works (tested with gopher://gopher.meulie.net//EFFector/ as well)
    return requestHandler(path: preparePath(path: request))
  }
}