/**
 * @mainpage Projekt 3
 * @link
 * proj3.h
 * @endlink
 *
 * @file proj3.h
 * @brief Projekt 3 - Jednoduchá zhluková analýza (Single linkage)
 * @author Adam Svenk <xsvenk00@stud.fit.vutbr.cz>
 * @date December 2018
 * @version 1.0
 */


 /**
  * @brief Štruktúra reprezentujúca objekt so súradnicami.
  */
struct obj_t {
    /** Identifikátor objektu */
    int id;
    /** Súradnica na osi X */
    float x;
    /** Súradnica na osi Y */
    float y;
};

/**
 * @brief Štruktúra reprezentujúca zhluk objektov.
 */
struct cluster_t {
    /** Počet objektov v zhluku */
    int size;
    /** Počet objektov, pre ktoré je alokované miesto v zhluku */
    int capacity;
    /** Počet objektov v zhluku */
    struct obj_t *obj;
};


/**
 * Inicializácia zhluku `c`, alokuje pamúť pre `cap` objektu.
 * Ukazovateľ NULL pri poli objektu znamená kapacitu 0.
 *
 * @post
 * V prípade, že pri alokácii nedôjde k chybe, alokuje pre zhluk `c` pamäť pre `cap` objektov.
 *
 * @param c zluk použitý na inicialzáciu
 * @param cap požadovaná kapacita zhluku
 */
void init_cluster(struct cluster_t *c, int cap);

/**
 * Odstránenie všetkých objektov zo zhluku `c` a inicializácia na prázdny zhluk.
 *
 * @post
 * Pamäť alokovaná pre všetky objekty zo zhluku `c` bude uvoľnená.
 *
 * @param c zhluk na odstránenie
 */
void clear_cluster(struct cluster_t *c);

/// Hodnota použitá pri realokácii zhluku
extern const int CLUSTER_CHUNK;

/**
 * Zmena kapacity zhluku `c` na kapacitu `new_cap`.
 *
 * @pre
 * Kapacita zhluku `c` bude väčšia, prípadne rovná 0.
 *
 * @post
 * V prípade, že pri alokácii nedôjde k chybe, zmení kapacitu zhluku `c` na novú kapacitu `new_cap`,
 *
 * @param c zhluk na zmenu kapacity
 * @param new_cap nová kapacita
 * @return zhluk s novou kapacitou, v prípade chyby NULL
 */
struct cluster_t *resize_cluster(struct cluster_t *c, int new_cap);

/**
 * Pridá objekt `obj` na koniec zhluku `c`. Rozšíri zhluk v prípade, že sa objekt do neho nevojde.
 *
 * @pre
 * Počet objektov v zhluku bude väčší, prípadne rovný 0.
 *
 * @post
 * Na poslednú pozíciu zhluku  Na posledni pozici shluku `c` bude objket `obj`,
 * pokud nenastane chyba pri alokaci.
 *
 * @param c shluk pro pridani objektu
 * @param obj objekt, ktery bude pridan do shluku
 */
void append_cluster(struct cluster_t *c, struct obj_t obj);

/**
 * Do zhluku `c1` pridá objekty `c2`. Zhluk `c1` bude v prípade nutnosti rozšírený.
 * Objekty v zhluku `c1` budú zoradené vzostupne podľa identifikačného čísla.
 * Zhluk `c2` bude nezmenený.
 *
 * @pre
 * Počet objektov v zhluku `c2` bude väčší, prípadne rovný 0.
 *
 * @post
 * V prípade, že pri alokácii nedôjde k chybe, rozšíri zhluk `c1` o objekty zhluku `c2`.
 *
 * @post
 * Objekty v zhluku `c1` budú vzostupne zoradené podľa ID.
 *
 * @param c1 zhluk, do ktorého budú priadené objekty zhluku `c2`
 * @param c2 zhluk, ktorého objekty budú pridané do zhluku `c1`
 */
void merge_clusters(struct cluster_t *c1, struct cluster_t *c2);

/**
 * Odstráni zhluk z poľa zhlukov 'carr'. Pole zhlukov obsahuje 'narr' položiek (zhlukov).
 * Zhluk určený na odstránenie sa nachádza na indexe 'idx'. Funkcia vracia nový počet zhlukov v poli.
 *
 * @post
 * Z poľa zhlukov `carr` odstráni prvok na indexe `idx` a zmenší pole o 1.
 *
 * @param carr pole zhlukov
 * @param narr počet zhlukov v poli
 * @param idx index zhluku na odstránenie
 * @return nový počet zhlukov v poli
 */
int remove_cluster(struct cluster_t *carr, int narr, int idx);

/**
 * Počíta Euklidovskú vzdialenosť medzi dvoma objektami.
 *
 * @see https://en.wikipedia.org/wiki/Euclidean_distance
 *
 * @param o1 prvý objekt
 * @param o2 druhý objekt
 * @return Euklidovská vzdialenosť medzi objektami `o1` a `o2`
 */
float obj_distance(struct obj_t *o1, struct obj_t *o2);

/**
 * Počíta vzdialenosť dvoch zhlukov.
 *
 * @pre
 * Počet objektov v zhluku `c1` bude väčší ako 0.
 *
 * @pre
 * Počet objektov v zhluku `c2` bude väčší ako 0.
 *
 * @param c1 prvý zhluk 1
 * @param c2 druhý zhluk 2
 * @return vzdialenosť zhlukov `c1` a `c2`
 */
float cluster_distance(struct cluster_t *c1, struct cluster_t *c2);

/**
 * V poli zhlukov `carr` veľkosti `narr` hľadá dva najbližšie zhluky.
 * Nájdené zhluky identifikuje indexami v poli `carr`.
 * Nájdené zhluky (indexy v poli `carr`) ukladá do pamäti na adresu `c1`, respektíve `c2`.
 *
 * @post
 * Indexy dvoch najbližších zhlukov budú uložené v premenných `c1` a `c2`.
 *
 * @param carr pole zhlukov
 * @param narr počet zhlukov v poli
 * @param c1 index jedného nájdeného zhluku
 * @param c2 index druhého nájdeného zhluku
 */
void find_neighbours(struct cluster_t *carr, int narr, int *c1, int *c2);

/**
 * Zoradenie objektov v zhluku vzostupne podľa ich ID.
 *
 * @post
 * Objekty v zhluku `c` budú zoradené vzostupne podľa ich ID.
 *
 * @param c zhluk na zoradenie
 */
void sort_cluster(struct cluster_t *c);

/**
 * Vypísanie zhlukov na stdout (štandardný výstup).
 *
 * @post
 * Objekty zhluku `c` budú vypíané na stdout (štandardný výstup).
 *
 * @param c zhluk určený na výpis
 */
void print_cluster(struct cluster_t *c);

/**
 * Zo súboru 'filename' načíta objekty. Pro kazdy objekt vytvori shluk a ulozi
 * jej do pole shluku. Alokuje prostor pro pole vsech shluku a ukazatel na prvni
 * polozku pole (ukalazatel na prvni shluk v alokovanem poli) ulozi do pameti,
 * kam se odkazuje parametr `arr`. Funkce vraci pocet nactenych objektu (shluku).
 * V pripade nejake chyby uklada do pameti, kam se odkazuje `arr`, hodnotu NULL.
*/
int load_clusters(char *filename, struct cluster_t **arr);

/**
 * Vypís poľa zhlukov. Parameter `carr` je ukazovateľ na prvú položku (zhluk).
 * Vypísanie prvých `narr` zhluku na stdout (štandardný výstup).
 *
 * @post
 * Objekty všetkých zhlukov v poli zhlukov `carr` budú vypísané na stdout (štandardný výstup).
 *
 * @param carr pole zhlukov na výpis
 * @param narr počet zhlukov v poli
 */
void print_clusters(struct cluster_t *carr, int narr);