#ifndef _XAS_DRONE_H
#define _XAS_DRONE_H

#include <stdarg.h>
#include <sys/time.h>

#include <xas/spatial.h>
#include <xas/vox.h>
#include <xas/seq.h>

#define XAS_DRONE_VOX_BUFFER_SIZE    735
#define XAS_DRONE_VOX_TEXT2WAVE_PATH "/usr/bin/text2wave"

#define XAS_DRONE_CHAMBER_BASS_FREQUENCY 20 /* Hz */
#define XAS_DRONE_CHAMBER_BASS_TYPE      XAS_SYNTH_SQUARE

enum xas_drone_mood {
    XAS_DRONE_MOOD_NEUTRAL,
    XAS_DRONE_MOOD_HAPPY,
    XAS_DRONE_MOOD_FLIRTY,
    XAS_DRONE_MOOD_SAD,
    XAS_DRONE_MOOD_ANGRY,
    XAS_DRONE_MOOD_DISTRESSED
};

typedef struct _xas_drone {
    xas_bank *bank;

    enum xas_drone_mood mood;

    xas_spatial_scene *scene;
    xas_spatial_object *obj;
} xas_drone;

typedef struct _xas_drone_vox {
    xas_drone *drone;
    xas_vox *obj;
} xas_drone_vox;

typedef struct _xas_drone_chamber_interval {
    struct timeval duration;

    size_t freq_l,
           freq_r;

    enum xas_synth_type type_l,
                          type_r;
} xas_drone_chamber_interval;

typedef struct _xas_drone_chamber {
    xas_drone **drones;
    size_t drone_count;

    xas_spatial_object *synth_bass,
                         *synth_l,
                         *synth_r;
} xas_drone_chamber;

/*
 * Methods for individual drones
 */
xas_drone *xas_drone_new(xas_spatial_scene *scene,
                             xas_spatial_coord position,
                             size_t bank_entry_size,
                             size_t bank_entry_count);

void xas_drone_destroy(xas_drone *drone);

enum xas_drone_mood xas_drone_mood_get(xas_drone *drone);

void xas_drone_mood_set(xas_drone *drone, enum xas_drone_mood mood);

xas_spatial_object *xas_drone_get_spatial_object(xas_drone *drone);

ssize_t xas_drone_sample_record(xas_drone *drone,
                                  xas_audio_stream *source,
                                  size_t sample_index,
                                  size_t sample_len);

ssize_t xas_drone_sample_import(xas_drone *drone,
                                  const char *file,
                                  size_t sample_index);

int xas_drone_speech_import(xas_drone *drone,
                              const char *voice,
                              float speed,
                              size_t sample_index,
                              size_t sample_count,
                              const char **speech_lines);

int xas_drone_seq_sample(xas_drone *drone,
                           xas_seq *seq,
                           size_t sample_index,
                           struct timeval *now);

/*
 * Methods for drone vocalisations
 */
xas_drone_vox *xas_drone_vox_new(xas_drone *drone);

void xas_drone_vox_destroy(xas_drone_vox *vox);

int xas_drone_vox_set_voice(xas_drone_vox *vox, const char *voice);

int xas_drone_vox_set_speed(xas_drone_vox *vox, float speed);

int xas_drone_vox_vsayf(xas_drone_vox *vox,
                          const char *format,
                          va_list args);

int xas_drone_vox_sayf(xas_drone_vox *vox, const char *format, ...);

int xas_drone_vox_say(xas_drone_vox *vox, const char *text);

int xas_drone_vox_save(xas_drone_vox *vox, size_t sample_index);

/*
 * Drone conversion chamber methods
 */
xas_drone_chamber *xas_drone_chamber_new(xas_spatial_scene *scene,
                                             xas_spatial_coord location,
                                             size_t drone_count);

void xas_drone_chamber_destroy(xas_drone_chamber *chamber);

void xas_drone_chamber_insert_drone(xas_drone_chamber *chamber,
                                      xas_drone *drone,
                                      size_t index);

void xas_drone_chamber_set_drone_gain(xas_drone_chamber *chamber, float gain);

void xas_drone_chamber_set_synth_gain(xas_drone_chamber *chamber, float gain);

void xas_drone_chamber_set_bass_gain(xas_drone_chamber *chamber, float gain);

void xas_drone_chamber_bass_start(xas_drone_chamber *chamber);

void xas_drone_chamber_bass_stop(xas_drone_chamber *chamber);

void xas_drone_chamber_bass_set_type(xas_drone_chamber *chamber,
                                       enum xas_synth_type type);

void xas_drone_chamber_bass_set_frequency(xas_drone_chamber *chamber,
                                            size_t freq);

int xas_drone_chamber_seq_intervals(xas_drone_chamber *chamber,
                                      xas_drone_chamber_interval *intervals,
                                      xas_seq *seq,
                                      size_t count,
                                      struct timeval *now);

int xas_drone_chamber_seq_chorus(xas_drone_chamber *chamber,
                                   xas_seq *seq,
                                   size_t speech_part,
                                   struct timeval *now);

#endif /* _XAS_DRONE_H */