#include <stdbool.h>
#include <stdio.h>
#include <time.h>
#include <errno.h>
#include <stdlib.h>

#define RATIO_GAIN_VILLAGEOIS_CIV_ECO 4
#define GAIN_VILLAGEOIS 2
#define COUT_VILLAGEOIS 5
#define COUT_SOLDAT 5
#define XP_MAX 5
#define GOLD_INIT 5
#define FORCE_BASE_SOLDAT 5
#define VIE_BASE_SOLDAT 5
#define VIE 1000
#define COUT_FORMATION_BASE 10
#define COUT_FORMATION_PAR_SOLDAT 1
#define GOLD_BASE 5
#define BONUS_DEFENSIF 2
#define TOUR_MAX 100

typedef struct {
  bool formation;
  int villageois;
  int soldat;
  bool attaque;
} reponse;

/* TOUTES VOS FONCTIONS DOIVENT SE TROUVER CI-DESSOUS */

reponse comportement1(int tour, int soldat[], int gold, int nb_villageois, int vie_chateau,
    int soldat_adversaire[], int civilisation_adversaire) {
  bool formation = false;
  int nb_achat_villageois = 0;
  int nb_achat_soldat = 0;
  bool attaque = false;
  /* if (nb_villageois > 0) { */
  /* nb_achat_soldat = 1; */
  /* } else { */
  nb_achat_villageois = (gold/COUT_VILLAGEOIS);
  /* } */
  /* if (rand() % 2 == 0) { */
  /* attaque = true; */
  /* }; */
  return (reponse){formation, nb_achat_villageois, nb_achat_soldat, attaque};
}
int civilisation_joueur_1 = 0;


/* TOUTES VOS FONCTIONS DOIVENT SE TROUVER CI-DESSUS */

/* Vous trouverez ci-dessous le code d'un autre joueur */
reponse comportement2(int tour, int soldat[], int gold, int nb_villageois,
    int vie_chateau, int soldat_adversaire[],
    int civilisation_adversaire) {
  bool formation = false;
  int nb_achat_villageois = 0;
  int nb_achat_soldat = 0;
  bool attaque = false;
  if (nb_villageois > 0) {
    nb_achat_soldat = 1;
  } else {
    nb_achat_villageois = 1;
  }
  if (rand() % 2 == 0) {attaque = true;};
  return (reponse) {formation, nb_achat_villageois, nb_achat_soldat, attaque};
}
int civilisation_joueur_2 = 0;

/* Ci-dessous des fonctions pour le jeu qu'il n'est pas nécessaire de lire / comprendre */
typedef struct {
  int x;
  int y;
} pair;

int depense(reponse r, int nb_soldat) {
  int total = r.villageois * COUT_VILLAGEOIS + r.soldat * COUT_SOLDAT;
  if (r.formation) {
    total += COUT_FORMATION_BASE + nb_soldat * COUT_FORMATION_PAR_SOLDAT;
  }
  return total;
}

int force_joueur(int soldats[], int len) {
  int force = 0;
  for (int i = 0; i < len; i++) {
    force += soldats[i] * (FORCE_BASE_SOLDAT + i);
  }
  return force;
}

void init0(int tab[], int tab_len) {
  for (int i = 0; i < tab_len; i++) {
    tab[i] = 0;
  }
}

void copie_tab(int source[], int dest[], int len) {
  for (int i = 0 ; i < len ; i ++) {
    dest[i] = source[i];
  }
  return ;
}

bool reste_soldats(int soldats_joueur[], int len) {
  bool reste_soldats = false;
  for (int j = 0; j < len && !reste_soldats; j++) {
    if (soldats_joueur[j] != 0) {
      reste_soldats = true;
    }
  }
  return reste_soldats;
}

int nb_soldats(int soldats[], int len) {
  int reste_soldats = 0;
  for (int j = 0; j < len; j++) {
    reste_soldats += soldats[j];
  }
  return reste_soldats;
}

int applique_combat(int civilisation_defense, bool defense, int soldats[], int len, int force) {
  int i = 0;
  int bonus_defensif;
  if (civilisation_defense == 2){bonus_defensif = 2*BONUS_DEFENSIF;} else{bonus_defensif = BONUS_DEFENSIF;};
  int vie_soldats = defense ? VIE_BASE_SOLDAT + bonus_defensif : VIE_BASE_SOLDAT;
  while (force >= vie_soldats && i < len) {
    if (soldats[i] == 0) {
      i = i + 1;
    } else {
      soldats[i] = soldats[i] - 1;
      force = force - vie_soldats;
    }
  }
  if (!reste_soldats(soldats, len)) {
    return force;
  } else {
    return 0;
  }
}

pair resoud_combat(int civilisation_joueur_1, int civilisation_joueur_2,
    bool bonus_defensif_joueur_1, bool bonus_defensif_joueur_2,
    int soldats_joueur_1[], int soldats_joueur_2[], int len) {
  int force_joueur_1 = force_joueur(soldats_joueur_1, len);
  int force_joueur_2 = force_joueur(soldats_joueur_2, len);
  int reste_force_joueur_2 = applique_combat(civilisation_joueur_1, bonus_defensif_joueur_1, soldats_joueur_1, len, force_joueur_2);
  int reste_force_joueur_1 = applique_combat(civilisation_joueur_2, bonus_defensif_joueur_2, soldats_joueur_2, len, force_joueur_1);
  reste_force_joueur_1 =
    reste_soldats(soldats_joueur_1, len) ? reste_force_joueur_1 : 0;
  reste_force_joueur_2 =
    reste_soldats(soldats_joueur_2, len) ? reste_force_joueur_2 : 0;
  return (pair){reste_force_joueur_1, reste_force_joueur_2};
}

void promotion(int soldats_joueur[], int len) {
  for (int i = XP_MAX - 1; i >= 0; i--) {
    if (i == XP_MAX - 1) {
      soldats_joueur[i] = soldats_joueur[i] + soldats_joueur[i-1];
    } else {
      soldats_joueur[i] = soldats_joueur[i-1];
    }
  }
  soldats_joueur[0] = 0;
}

void applique_depenses(int civilisation_joueur, int soldats_joueur[], int* nb_villageois, reponse depense) {
  if (depense.formation) {
    promotion(soldats_joueur, XP_MAX);
  }
  if (civilisation_joueur == 0) {
    soldats_joueur[1] += depense.soldat;
  } else {soldats_joueur[0] += depense.soldat;}
  if (civilisation_joueur == 1) {
    *nb_villageois += depense.villageois + (depense.villageois / RATIO_GAIN_VILLAGEOIS_CIV_ECO);
  } else {
    *nb_villageois += depense.villageois;
  }
}

void print_soldat_tab(int soldats[], int len) {
  for (int i = 0; i < len-1; i++) {
    printf("%d, ", soldats[i]);
  }
  printf("%d", soldats[len-1]);
}

int max(int a, int b) {
  return a > b ? a : b;
}

void print_etat(int id, int gold, int civ, int soldats[], int nb_villageois, int len, int vie) {
  printf("======== JOUEUR %d ========\n", id);
  printf("  civ        : %d\n", civ);
  printf("  gold       : %d\n", gold);
  printf("  villageois : %d\n", nb_villageois);
  printf("  soldats    : ");
  print_soldat_tab(soldats, len);
  printf("\n");
  printf("  vie        : %d\n", vie);
  printf("==========================\n");
}

void print_reponse(int id, reponse rep) {
  printf("===== DEP. JOUEUR %d ====== \n", id);
  printf("  villageois   : %d\n", rep.villageois);
  printf("  soldat       : %d\n", rep.soldat);
  printf("  formation    : %d\n", rep.formation);
  printf("==========================\n");
}

bool depense_valide(reponse rep, int nb_soldat, int gold) {
  return (depense(rep, nb_soldat) <= gold && rep.villageois >= 0 && rep.soldat >= 0);
}

typedef struct {
  int vie1;
  int vie2;

  int eco1;
  int eco2;

  int force1;
  int force2;
} gamelog;

int moteur(gamelog logs[TOUR_MAX]) {
  srand(time(NULL));
  int nb_villageois_joueur_1 = 0;
  int nb_villageois_joueur_2 = 0;

  int soldats_joueur_1[XP_MAX];
  int soldats_joueur_2[XP_MAX];

  int copie_soldats_joueur_1[XP_MAX];
  int copie_soldats_joueur_2[XP_MAX];

  int gold_joueur_1 = GOLD_INIT;
  int gold_joueur_2 = GOLD_INIT;

  int vie_joueur_1 = VIE;
  int vie_joueur_2 = VIE;

  reponse reponse_joueur_1 ;
  reponse reponse_joueur_2 ;

  int depense_joueur_1;
  int depense_joueur_2;

  pair resultat_combat;
  bool bataille;
  bool bonus_defensif_joueur_1 = false;
  bool bonus_defensif_joueur_2 = false;

  init0(soldats_joueur_1, XP_MAX);
  init0(soldats_joueur_2, XP_MAX);
  copie_tab(soldats_joueur_1, copie_soldats_joueur_1, XP_MAX);
  copie_tab(soldats_joueur_2, copie_soldats_joueur_2, XP_MAX);
  int tour = 0;

  while (vie_joueur_1 > 0 && vie_joueur_2 > 0 && tour < TOUR_MAX) {
    int force_j1 = force_joueur(soldats_joueur_1, XP_MAX);
    int force_j2 = force_joueur(soldats_joueur_2, XP_MAX);
    gamelog gl = {vie_joueur_1, vie_joueur_2, nb_villageois_joueur_1, nb_villageois_joueur_2, force_j1, force_j2};
    logs[tour] = gl;
    printf("\n\n          TOUR %d\n\n\n", tour);
    print_etat(1, gold_joueur_1, civilisation_joueur_1, soldats_joueur_1, nb_villageois_joueur_1,XP_MAX, vie_joueur_1);
    print_etat(2, gold_joueur_2, civilisation_joueur_2, soldats_joueur_2, nb_villageois_joueur_2,XP_MAX, vie_joueur_2);
    copie_tab(soldats_joueur_1, copie_soldats_joueur_1, XP_MAX);
    copie_tab(soldats_joueur_2, copie_soldats_joueur_2, XP_MAX);
    reponse_joueur_1 = comportement1(tour, copie_soldats_joueur_1, gold_joueur_1, nb_villageois_joueur_1, vie_joueur_1, copie_soldats_joueur_2, civilisation_joueur_2);
    copie_tab(soldats_joueur_1, copie_soldats_joueur_1, XP_MAX);
    copie_tab(soldats_joueur_2, copie_soldats_joueur_2, XP_MAX);
    reponse_joueur_2 = comportement2(tour, copie_soldats_joueur_2, gold_joueur_2, nb_villageois_joueur_2, vie_joueur_2, copie_soldats_joueur_1, civilisation_joueur_1);
    print_reponse(1, reponse_joueur_1);
    print_reponse(2, reponse_joueur_2);
    /* Phase de dépense */
    depense_joueur_1 = depense(reponse_joueur_1, nb_soldats(soldats_joueur_1, XP_MAX));
    depense_joueur_2 = depense(reponse_joueur_2, nb_soldats(soldats_joueur_2, XP_MAX));
    if (depense_valide(reponse_joueur_1, nb_soldats(soldats_joueur_1, XP_MAX), gold_joueur_1)) {
      gold_joueur_1 = gold_joueur_1 - depense_joueur_1;
      applique_depenses(civilisation_joueur_1, soldats_joueur_1, &nb_villageois_joueur_1, reponse_joueur_1);
    } else {
      printf("*** WARNING *** : le joueur 1 a demandé une dépense non valide, elle est ignorée\n");
    }
    if (depense_valide(reponse_joueur_2,nb_soldats(soldats_joueur_2, XP_MAX), gold_joueur_2)) {
      gold_joueur_2 = gold_joueur_2 - depense_joueur_2;
      applique_depenses(civilisation_joueur_2, soldats_joueur_2, &nb_villageois_joueur_2, reponse_joueur_2);
    } else {
      printf("*** WARNING *** : le joueur 2 a demandé une dépense non valide, elle est ignorée\n");
    }
    /* Phase de combat */
    bataille = reponse_joueur_1.attaque || reponse_joueur_2.attaque;
    bonus_defensif_joueur_1 = reponse_joueur_2.attaque && (!reponse_joueur_1.attaque);
    bonus_defensif_joueur_2 = reponse_joueur_1.attaque && (!reponse_joueur_2.attaque);
    if (reponse_joueur_1.attaque && reponse_joueur_2.attaque) {
      printf("Les deux joueurs attaquent, aucun bonus défensif\n");
    } else if (reponse_joueur_1.attaque && !reponse_joueur_2.attaque) {
      printf("Le joueur 1 attaque, bonus défensif pour le joueur 2\n");
    } else if (reponse_joueur_2.attaque && !reponse_joueur_1.attaque) {
      printf("Le joueur 2 attaque, bonus défensif pour le joueur 1\n");
    } else {
      printf("Aucun joueur n'attaque\n");
    }
    if (bataille) {
      printf("======== BATAILLE ========\n");
      printf("JOUEUR 1: "); print_soldat_tab(soldats_joueur_1, XP_MAX); printf("\n");
      printf("JOUEUR 2: "); print_soldat_tab(soldats_joueur_2, XP_MAX); printf("\n");
      printf("==========================\n");
      resultat_combat = resoud_combat(civilisation_joueur_1, civilisation_joueur_2, bonus_defensif_joueur_1, bonus_defensif_joueur_2, soldats_joueur_1, soldats_joueur_2, XP_MAX);
      vie_joueur_2 = vie_joueur_2 - resultat_combat.x;
      vie_joueur_1 = vie_joueur_1 - resultat_combat.y;
    }
    /* Mise à jour de l'argent */
    gold_joueur_1 = gold_joueur_1 + GOLD_BASE + nb_villageois_joueur_1 * GAIN_VILLAGEOIS;
    gold_joueur_2 = gold_joueur_2 + GOLD_BASE + nb_villageois_joueur_2 * GAIN_VILLAGEOIS;
    /* Promotions */
    if (bataille) {
      promotion(soldats_joueur_1, XP_MAX);
      promotion(soldats_joueur_2, XP_MAX);
    }
    tour = tour + 1;
  }
  if ((vie_joueur_1 < 0 && vie_joueur_2 < 0) || (vie_joueur_1 > 0 && vie_joueur_2 > 0)) { return 0; }
  else if (vie_joueur_1 < 0) { return 2; }
  else { return 1; }
}

int main() {
  gamelog logs[TOUR_MAX];
  int x = moteur(logs);
  printf("GAGNANT : %d\n", x);
}