#include <arpa/inet.h>
#include <cstring>
#include <fcntl.h>
#include <iomanip>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <netinet/in.h>
#include <ostream>
#include <pthread.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

#ifdef __SWITCH__
#include <server.hpp>
#include <switch.h>
#include <main.hpp>
#endif

#define PORT 8080
#define BUFFER_SIZE 65536
#define MULTICAST_PORT 8081
#define MULTICAST_GROUP "239.0.0.1" // Multicast group IP

namespace fs = std::filesystem;

#ifdef __SWITCH__
std::string replaceUsername(const std::string &path) {
  std::string replacedString = StringUtils::removeNotAscii(
      StringUtils::removeAccents(Account::username(g_currentUId)));
  // Найдём позицию последнего символа '/'
  size_t lastSlashPos = path.rfind('/');

  // Если нет '/', возвращаем исходный путь
  if (lastSlashPos == std::string::npos) {
    return path;
  }

  // Найдём позицию предыдущего символа '/' (начало последней папки)
  size_t prevSlashPos = path.rfind('/', lastSlashPos - 1);

  // Если предыдущий '/' не найден, значит путь состоит из одной папки и файла
  // Заменим последнюю папку и вернём полный путь
  if (prevSlashPos == std::string::npos) {
    return replacedString + path.substr(lastSlashPos);
  }

  // Собираем путь, заменяя последнюю папку на "name"
  return path.substr(0, prevSlashPos + 1) + replacedString +
         path.substr(lastSlashPos);
}
#endif

// Читает ровно len байт из сокета, повторяя read при частичном получении.
static bool recv_all(int sock, void *buf, size_t len) {
  size_t received = 0;
  while (received < len) {
    ssize_t n = read(sock, static_cast<char *>(buf) + received, len - received);
    if (n <= 0) return false;
    received += n;
  }
  return true;
}

// Создаёт все компоненты пути через POSIX mkdir.
// std::filesystem::create_directories не работает с devkitPro-путями sdmc:/.
static void mkdirs(const std::string &path) {
  for (size_t i = 1; i < path.size(); i++) {
    if (path[i] == '/') {
      std::string component = path.substr(0, i);
      int rc = mkdir(component.c_str(), 0777);
      std::cout << "mkdirs: mkdir [" << component << "] rc=" << rc << " errno=" << errno << std::endl;
    }
  }
  int rc = mkdir(path.c_str(), 0777);
  std::cout << "mkdirs: mkdir [" << path << "] rc=" << rc << " errno=" << errno << std::endl;
}

// Функция для получения файла
void receive_file(int sock, const std::string &relative_path,
                  size_t file_size) {
  std::cout << "relative_path is: " << relative_path << std::endl;

  // Печатаем путь побайтово — ловим невидимые символы
  std::cout << "receive_file len=" << relative_path.size() << " path=[";
  for (unsigned char c : relative_path) {
    if (c >= 0x20 && c <= 0x7e) std::cout << c;
    else std::cout << "\\x" << std::hex << std::setw(2) << std::setfill('0') << (int)c << std::dec;
  }
  std::cout << "]" << std::endl;

  size_t last_slash = relative_path.rfind('/');
  std::string dir = (last_slash != std::string::npos)
                    ? relative_path.substr(0, last_slash)
                    : "";
  std::cout << "receive_file dir=[" << dir << "]" << std::endl;
  if (!dir.empty()) mkdirs(dir);

  // Проверяем stat на папке перед fopen
  struct stat st;
  int statrc = stat(dir.c_str(), &st);
  std::cout << "stat(dir) rc=" << statrc << " is_dir="
            << (statrc == 0 && S_ISDIR(st.st_mode)) << std::endl;

  FILE *outfile = fopen(relative_path.c_str(), "wb");
  if (!outfile) {
    int saved_errno = errno;
    std::cerr << "Failed to open for writing: " << relative_path
              << " dir=[" << dir << "] fopen_errno=" << saved_errno << std::endl;
    // Дренируем байты, чтобы отправитель не завис
    char* drain_buf = new char[BUFFER_SIZE];
    size_t remaining = file_size;
    while (remaining > 0) {
      ssize_t n = read(sock, drain_buf, remaining < (size_t)BUFFER_SIZE ? remaining : (size_t)BUFFER_SIZE);
      if (n <= 0) break;
      remaining -= n;
    }
    delete[] drain_buf;
    return;
  }

  char* buffer = new char[BUFFER_SIZE]();
  size_t total_bytes_received = 0;
  while (total_bytes_received < file_size) {
    size_t to_read = std::min((size_t)BUFFER_SIZE, file_size - total_bytes_received);
    ssize_t bytes_received = read(sock, buffer, to_read);
    std::cout << "Bytes received: " << bytes_received << std::endl;
    if (bytes_received <= 0) {
      std::cerr << "Error reading file data from socket." << std::endl;
      break;
    }
    fwrite(buffer, 1, bytes_received, outfile);
    total_bytes_received += bytes_received;
  }

  std::cout << "File received successfully: " << relative_path << std::endl;
  delete[] buffer;
  fclose(outfile);
}

void *handle_client(void *socket_desc) {
  int client_socket = *(int *)socket_desc;
  free(socket_desc);

  std::cout << "Обработка нового клиента в потоке " << pthread_self() << "\n";

  while (true) {

    uint32_t filename_len;
    ssize_t bytes_read =
        read(client_socket, &filename_len, sizeof(filename_len));

    // Check for end-of-transmission signal
    if (bytes_read <= 0 || filename_len == 0) {
      std::cout << "End of transmission detected." << std::endl;
      break;
      pthread_exit(nullptr);
    }

    // Receive filename
    char *filename = new char[filename_len + 1]();
    if (!recv_all(client_socket, filename, filename_len)) {
      std::cerr << "Short read on filename, aborting." << std::endl;
      delete[] filename;
      break;
    }
    filename[filename_len] = '\0';
    std::string filename_str(filename);
    delete[] filename;

    std::cout << "Received filename_str is " << filename_str << std::endl;

    #ifdef __SWITCH__
      std::cout << "Replaced filename from " << filename_str << std::endl;
      filename_str = replaceUsername(filename_str);
      std::cout << "to " << filename_str << std::endl;
    #endif

    size_t file_size;
    if (!recv_all(client_socket, &file_size, sizeof(file_size))) {
      std::cerr << "Short read on file_size, aborting." << std::endl;
      break;
    }
    std::cout << "file size is: " << file_size << std::endl;
    receive_file(client_socket, filename_str, file_size);
  }

  close(client_socket);
  pthread_exit(nullptr);
}

void *broadcast_listener(void *) {
  int sockfd;
  struct sockaddr_in servaddr;
  char buffer[BUFFER_SIZE + 1];
  struct ip_mreq group;

  if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
    perror("socket creation failed");
    pthread_exit(nullptr);
  }

  memset(&servaddr, 0, sizeof(servaddr));
  servaddr.sin_family = AF_INET;
  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  servaddr.sin_port = htons(MULTICAST_PORT);

  if (bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr))) {
    perror("binding datagram socket");
    close(sockfd);
    pthread_exit(nullptr);
  }

  group.imr_multiaddr.s_addr = inet_addr(MULTICAST_GROUP);
  group.imr_interface.s_addr = htonl(INADDR_ANY);

  if (setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *)&group,
                 sizeof(group)) < 0) {
    perror("setsockopt failed");
    close(sockfd);
    pthread_exit(nullptr);
  }

  std::cout << "Broadcast listener started" << std::endl;
  struct sockaddr_in client_addr;
  socklen_t addr_len = sizeof(client_addr);
  while (true) {
    int n = recvfrom(sockfd, buffer, BUFFER_SIZE, 0,
                     (struct sockaddr *)&client_addr, &addr_len);
    if (n < 0) {
      perror("recvfrom failed");
      continue;
    }
    std::cout << buffer << std::endl;
    buffer[n] = '\0';
    if (strcmp(buffer, "DISCOVER_SERVER") == 0) {
      const char *message = "SERVER_HERE";
      sendto(sockfd, message, strlen(message), 0,
             (const struct sockaddr *)&client_addr, addr_len);
      std::cout << "Server discovery response sent to multicast group"
                << std::endl;
      
      pthread_exit(0);
    }
  }

  close(sockfd);
  pthread_exit(nullptr);
}

int startSendingThread() {
  pthread_t broadcast_thread;
  if (pthread_create(&broadcast_thread, nullptr, broadcast_listener, nullptr) <
      0) {
    perror("Thread creation failed");
    return 1;
  }

  int server_fd, new_socket;
  struct sockaddr_in address;
  socklen_t addrlen = sizeof(address);

  if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
    perror("Socket creation failed");
    exit(EXIT_FAILURE);
  }

  address.sin_family = AF_INET;
  address.sin_addr.s_addr = INADDR_ANY;
  address.sin_port = htons(PORT);

  if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
    perror("Bind failed");
    close(server_fd);
    exit(EXIT_FAILURE);
  }

  if (listen(server_fd, 3) < 0) {
    perror("Listen failed");
    close(server_fd);
    exit(EXIT_FAILURE);
  }

  std::cout << "Wait for broadcast thread done " << std::endl;

  pthread_join(broadcast_thread, NULL);

  std::cout << "Broadcast thread done " << std::endl;

  std::cout << "Server listening on port " << PORT << std::endl;

  while (true) {
    sockaddr_in client_address;
    socklen_t client_len = sizeof(client_address);
    int client_socket =
        accept(server_fd, (sockaddr *)&client_address, &client_len);

    if (client_socket < 0) {
      std::cerr << "Ошибка принятия подключения\n";
      continue;
    }

    // Создаем новый поток для обработки клиента
    pthread_t thread_id;
    int *pclient = new (std::nothrow) int(client_socket);
    if (!pclient) {
      std::cerr << "Ошибка выделения памяти\n";
      close(client_socket);
      continue;
    }
    if (pthread_create(&thread_id, nullptr, handle_client, pclient) != 0) {
      std::cerr << "Ошибка создания потока\n";
      delete pclient; // Освобождаем память при ошибке
    } else {
      pthread_join(thread_id, NULL); 
      break;
    }
  }

  close(server_fd);
  return 0;
}

#ifndef __SWITCH__ // for desktop
int main() {
  return startSendingThread();
}
#endif