#include <arpa/inet.h>
#include <cstring>
#include <fcntl.h>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <netinet/in.h>
#include <ostream>
#include <pthread.h>
#include <string.h>
#include <sys/socket.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 1024
#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 = 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

void sendAck(int sock) {
  const char *ack = "ACK";
  std::cout << "Sending ACK " << std::endl;
  send(sock, ack, strlen(ack), 0);
}

// Функция для получения файла
void receive_file(int sock, const std::string &relative_path,
                  size_t file_size) {
  fs::path filepath(relative_path);
  // Create parent directories if they do not exist

  std::cout << "relative_path is: " << relative_path << std::endl;

  fs::create_directories(filepath.parent_path());

  std::ofstream outfile(filepath, std::ios::binary);
  char buffer[BUFFER_SIZE] = {0};

  size_t total_bytes_received = 0;
  while (total_bytes_received < file_size) {
    ssize_t bytes_received = read(sock, buffer, BUFFER_SIZE);
    std::cout << "Bytes received: " << bytes_received << std::endl;
    if (bytes_received <= 0) {
      std::cerr << "Error reading file data from socket." << std::endl;
      break;
    }
    outfile.write(buffer, bytes_received);
    total_bytes_received += bytes_received;

    // Send acknowledgment for each chunk received
    sendAck(sock);
  }

  std::cout << "File received successfully: " << relative_path << std::endl;
  outfile.close();
}

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 or directory name
    char *filename = new char[filename_len + 1];
    read(client_socket, filename, filename_len);

    filename[filename_len] = '\0';
    std::string filename_str(filename);
    std::cout << "Receive filename: " << filename_str << std::endl;
    delete[] filename; // Clean up filename buffer

    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;
    read(client_socket, &file_size, sizeof(file_size));
    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];
  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