#include <iostream>
#include <vector>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sstream>

#define MAX_CLIENTS 5
#define BUFLEN 256

void error(char *msg)
{
    perror(msg);
    exit(0);
}

class User{
public:
  char name[12];
  char surname[12];
  int cardNumber;
  int pin;
  char password[16];
  double sold;
  bool inUse;
  int attempts;
  int sockfd;

  User(char givenName[12], char givenSurname[12], int cardNumber,
       int pin, char givenPassword[12],
       double sold) : cardNumber(cardNumber), pin(pin), sold(sold) {
    strcpy(name, givenName);
    strcpy(surname, givenSurname);
    strcpy(password, givenPassword);
    inUse = false;
    attempts = 0;
    sockfd = -1;
  }

  void printStats(){
    std::cout << "Name: " << name << " " << surname << " ";
    std::cout << "Card Number: " << cardNumber << ", PIN: " << pin << " ";
    std::cout << "Password: " << password << ", Sold: " << sold << std::endl;
  }
};

User* getUserByCard(std::vector<User> users, int cardNumber){
  for(int i = 0; i < users.size(); ++i){
    if(users[i].cardNumber == cardNumber){
      User *ret = new User(users[i].name, users[i].surname, users[i].cardNumber, users[i].pin, users[i].password, users[i].sold);
      return ret;
    }
  }
  return nullptr;
}

bool checkIfOpen(std::vector<int> cards, int card){
  for(int i = 0; i < cards.size(); ++i){
    if(cards[i] == card){
      return true;
    }
  }
  return false;
}

bool checkIfSessionOpen(std::vector<User> users, int sockfd){
  for(int i = 0; i < users.size(); ++i){
    if(users[i].sockfd == sockfd){
      return true;
    }
  }
  return false;
}

int main(int argc, char *argv[])
{
    int tcp_fd, udp_fd, new_tcp_fd, portno;
    unsigned int clilen;
    char buffer[BUFLEN];
    struct sockaddr_in tcp_addr, new_tcp_addr, udp_addr;
    int numberOfUsers;
    int n, status;
    std::vector<User> users;
    std::vector<int> openCards;

    FILE *fin = fopen(argv[2], "r");

    fscanf(fin, "%d", &numberOfUsers);
    for(int i = 0; i < numberOfUsers; ++i){
      char name[12];
      char surname[12];
      int cardNumber;
      int pin;
      char password[16];
      double sold;
      fscanf(fin, "%s", name);
      fscanf(fin, "%s", surname);
      fscanf(fin, "%d", &cardNumber);
      fscanf(fin, "%d", &pin);
      fscanf(fin, "%s", password);
      fscanf(fin, "%lf", &sold);
      User *currUser = new User(name, surname, cardNumber, pin, password, sold);
      users.push_back(*currUser);
    }

    tcp_fd = socket(AF_INET, SOCK_STREAM, 0);
    udp_fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (tcp_fd < 0)
        printf("ERROR opening socket");

    portno = atoi(argv[1]);

    memset((char *) &tcp_addr, 0, sizeof(tcp_addr));
    tcp_addr.sin_family = AF_INET;
    tcp_addr.sin_addr.s_addr = INADDR_ANY; // foloseste adresa IP a masinii
    tcp_addr.sin_port = htons(portno);

    if (bind(tcp_fd, (struct sockaddr *) &tcp_addr, sizeof(struct sockaddr)) < 0)
            printf("ERROR on binding");

    if (bind(udp_fd, (struct sockaddr *) &tcp_addr, sizeof(struct sockaddr)) < 0)
            printf("ERROR on binding UDP");

    listen(tcp_fd, 5);

    //adaugam noul file descriptor (socketul pe care se asculta conexiuni) in multimea read_fds

    fd_set read_fds;    //multimea de citire folosita in select()
    fd_set tmp_fds; //multime folosita temporar
    int fdmax;      //valoare maxima file descriptor din multimea read_fds
    //golim multimea de descriptori de citire (read_fds) si multimea tmp_fds
    FD_ZERO(&read_fds);
    FD_ZERO(&tmp_fds);
    FD_SET(tcp_fd, &read_fds);
    FD_SET(udp_fd, &read_fds);
    fdmax = std::max(tcp_fd, udp_fd);
    FD_SET(STDIN_FILENO, &read_fds);

    // main loop
    while (1) {
        tmp_fds = read_fds;
        if (select(fdmax + 1, &tmp_fds, NULL, NULL, NULL) == -1)
            printf("ERROR in select");

        for(int i = 0; i <= fdmax; i++) {
            if (FD_ISSET(i, &tmp_fds)) {
                if(i == STDIN_FILENO) {
                    memset(buffer, 0, 255);
                    fgets(buffer, 255, stdin);
                    printf("Ai scris pe server: %s", buffer);
                    if(strncmp(buffer, "quit", 4) == 0){
                        printf("Closing server..\n");
                        std::string buf = "quit";
                        strcpy(buffer, buf.c_str());
                        buffer[buf.size()] = '\0';
                        FD_CLR(tcp_fd, &read_fds);
                        FD_CLR(STDIN_FILENO, &read_fds);
                        for(int k = 3; k <= fdmax; ++k){
                          if(FD_ISSET(k, &read_fds)){
                            printf("Sending to %d close message.\n", k);
                            status = send(k, buffer, strlen(buffer), 0);
                            FD_CLR(k, &read_fds);
                          }
                        }
                        close(tcp_fd);
                        return 0;
                    }
                }
                else if (i == tcp_fd) {
                    // a venit ceva pe socketul inactiv(cel cu listen) = o noua conexiune
                    // actiunea serverului: accept()
                    clilen = sizeof(new_tcp_addr);
                    if ((new_tcp_fd = accept(tcp_fd, (struct sockaddr *)&new_tcp_addr, &clilen)) == -1) {
                        printf("ERROR in accept");
                    }
                    else {
                        //adaug noul socket intors de accept() la multimea descriptorilor de citire
                        FD_SET(new_tcp_fd, &read_fds);
                        if (new_tcp_fd > fdmax) {
                            fdmax = new_tcp_fd;
                        }
                    }
                    printf("Noua conexiune de la %s, port %d, socket_client %d\n ", inet_ntoa(new_tcp_addr.sin_addr), ntohs(new_tcp_addr.sin_port), new_tcp_fd);
                }

                else if (i == udp_fd){
                  clilen = sizeof(udp_addr);
                  recvfrom(udp_fd, buffer, BUFLEN, 0, (struct sockaddr*) &udp_addr, &clilen);
                  printf("WE DID IT REDDIT");
                }

                else {
                    // am primit date pe unul din socketii cu care vorbesc cu clientii
                    //actiunea serverului: recv()
                    memset(buffer, 0, BUFLEN);
                    if ((n = recv(i, buffer, sizeof(buffer), 0)) <= 0) {
                        if (n == 0) {
                            //conexiunea s-a inchis
                            printf("selectserver: socket %d hung up\n", i);
                        } else {
                            printf("ERROR in recv");
                        }
                        close(i);
                        FD_CLR(i, &read_fds); // scoatem din multimea de citire socketul pe care
                    }

                    else { //recv intoarce >0
                        printf("Am primit de la clientul de pe socketul %d, mesajul: %s", i, buffer);
                        // trimit mesajul inapoi
                        std::string buf(buffer); // Have a buffer string

                        std::vector<std::string> tokens;

                        char *token = strtok(buffer, " \t");
                        while (token) {
                          std::string curr(token);
                          tokens.push_back(curr);
                          token = strtok(NULL, " \t");
                        }

                        if(!checkIfSessionOpen(users, i) && tokens[0] != "login"){
                          buf = ">ATM: -1 : Nu esti autentificat.";
                        }

                        else if(tokens[0] == "login"){
                          int tmpCardNumber = stoi(tokens[1]);
                          int tmpPin = stoi(tokens[2]);
                          User *aux = NULL;
                          for(int k = 0; k < users.size(); ++k){
                            if(users[k].cardNumber == tmpCardNumber){
                              aux = &users[k];
                              break;
                            }
                          }
                          if(aux == NULL){
                            buf = ">ATM: -4 : Numar card inexistent.";
                          }
                          else{
                            if(checkIfOpen(openCards, tmpCardNumber)){
                              buf = ">ATM: -2 : Sesiune deja deschisa.";
                            }
                            else if(aux->pin == tmpPin){
                              openCards.push_back(tmpCardNumber);
                              buf = ">ATM: Welcome, ";
                              buf += aux->name;
                              buf += " ";
                              buf += aux->surname;
                              aux->sockfd = i;
                            }
                            else{
                              buf = "ATM: -3 : Pin gresit";
                            }
                          }
                        }
                        else if(tokens.size() == 1 && !strncmp(buffer, "logout", 6)){
                          buf = ">ATM: Deconectare de la bancomat.";
                          for(int k = 0; k < users.size(); ++k){
                            if(users[k].sockfd == i){
                              users[k].sockfd = -1;
                              break;
                            }
                          }
                        }

                        else if(tokens.size() == 1 && !strncmp(buffer, "listsold", 8)){
                          buf = ">ATM: Sold: ";
                          for(int k = 0; k < users.size(); ++k){
                            if(users[k].sockfd == i){
                              std::ostringstream strs;
                              strs << users[k].sold;
                              std::string str = strs.str();
                              buf += str;
                              break;
                            }
                          }
                        }

                        else if(tokens[0] == "getmoney"){
                          int money = stoi(tokens[1]);
                          if(money % 10 != 0){
                            buf = ">ATM: -9 : Suma nu este multiplu de 10.";
                          }
                          else{
                            for(int k = 0; k < users.size(); ++k){
                              if(users[k].sockfd == i){
                                if(users[k].sold > money){
                                  buf = ">ATM: Suma ";
                                  std::ostringstream strs;
                                  strs << money;
                                  std::string str = strs.str();
                                  buf += str;
                                  buf += " a fost retrasa cu succes";
                                  users[k].sold -= money;
                                }
                                else{
                                  buf = ">ATM: -8 : Fonduri insuficiente.";
                                }
                                break;
                              }
                            }
                          }
                        }
                        else if(tokens[0] == "putmoney"){
                          double money = stod(tokens[1]);
                          for(int k = 0; k < users.size(); ++k){
                            if(users[k].sockfd == i){
                              users[k].sold += money;
                              buf = ">ATM: Suma a fost depusa cu succes.";
                            }
                          }
                        }
                        // else if(tokens.size() == 1 && !strncmp(buffer, "quit", 4)){
                        //   buf =
                        // }
                        else{
                          buf = "None of the above";
                        }
                        strcpy(buffer, buf.c_str());
                        buffer[buf.size()] = '\0';
                        status = send(i, buffer, strlen(buffer) + 1, 0);
                    }
                }
            }
        }
    }


    close(tcp_fd);
    fclose(fin);
}