#include <stdio.h>
#include <string.h>
#include <glib.h>
#include <glib/gstdio.h>
#include "plist.h"
#include "values.h"

static GValue *defaults;

typedef struct
{
    gchar *mac_val;
    gchar *lin_val;
} value_map_t;

#if 0
static value_map_t subtitle_xlat[] =
{ 
    { "None", "none" },
    { "Auto", "auto" },
    { "Any", "und" },
    { "Afar", "aar" },
    { "Abkhazian", "abk" },
    { "Afrikaans", "afr" },
    { "Akan", "aka" },
    { "Albanian", "sqi" },
    { "Amharic", "amh" },
    { "Arabic", "ara" },
    { "Aragonese", "arg" },
    { "Armenian", "hye" },
    { "Assamese", "asm" },
    { "Avaric", "ava" },
    { "Avestan", "ave" },
    { "Aymara", "aym" },
    { "Azerbaijani", "aze" },
    { "Bashkir", "bak" },
    { "Bambara", "bam" },
    { "Basque", "eus" },
    { "Belarusian", "bel" },
    { "Bengali", "ben" },
    { "Bihari", "bih" },
    { "Bislama", "bis" },
    { "Bosnian", "bos" },
    { "Breton", "bre" },
    { "Bulgarian", "bul" },
    { "Burmese", "mya" },
    { "Catalan", "cat" },
    { "Chamorro", "cha" },
    { "Chechen", "che" },
    { "Chinese", "zho" },
    { "Church Slavic", "chu" },
    { "Chuvash", "chv" },
    { "Cornish", "cor" },
    { "Corsican", "cos" },
    { "Cree", "cre" },
    { "Czech", "ces" },
    { "Danish", "dan" },
    { "Divehi", "div" },
    { "Dutch", "nld" },
    { "Dzongkha", "dzo" },
    { "English", "eng" },
    { "Esperanto", "epo" },
    { "Estonian", "est" },
    { "Ewe", "ewe" },
    { "Faroese", "fao" },
    { "Fijian", "fij" },
    { "Finnish", "fin" },
    { "French", "fra" },
    { "Western Frisian", "fry" },
    { "Fulah", "ful" },
    { "Georgian", "kat" },
    { "German", "deu" },
    { "Gaelic (Scots)", "gla" },
    { "Irish", "gle" },
    { "Galician", "glg" },
    { "Manx", "glv" },
    { "Greek, Modern", "ell" },
    { "Guarani", "grn" },
    { "Gujarati", "guj" },
    { "Haitian", "hat" },
    { "Hausa", "hau" },
    { "Hebrew", "heb" },
    { "Herero", "her" },
    { "Hindi", "hin" },
    { "Hiri Motu", "hmo" },
    { "Hungarian", "hun" },
    { "Igbo", "ibo" },
    { "Icelandic", "isl" },
    { "Ido", "ido" },
    { "Sichuan Yi", "iii" },
    { "Inuktitut", "iku" },
    { "Interlingue", "ile" },
    { "Interlingua", "ina" },
    { "Indonesian", "ind" },
    { "Inupiaq", "ipk" },
    { "Italian", "ita" },
    { "Javanese", "jav" },
    { "Japanese", "jpn" },
    { "Kalaallisut", "kal" },
    { "Kannada", "kan" },
    { "Kashmiri", "kas" },
    { "Kanuri", "kau" },
    { "Kazakh", "kaz" },
    { "Central Khmer", "khm" },
    { "Kikuyu", "kik" },
    { "Kinyarwanda", "kin" },
    { "Kirghiz", "kir" },
    { "Komi", "kom" },
    { "Kongo", "kon" },
    { "Korean", "kor" },
    { "Kuanyama", "kua" },
    { "Kurdish", "kur" },
    { "Lao", "lao" },
    { "Latin", "lat" },
    { "Latvian", "lav" },
    { "Limburgan", "lim" },
    { "Lingala", "lin" },
    { "Lithuanian", "lit" },
    { "Luxembourgish", "ltz" },
    { "Luba-Katanga", "lub" },
    { "Ganda", "lug" },
    { "Macedonian", "mkd" },
    { "Marshallese", "mah" },
    { "Malayalam", "mal" },
    { "Maori", "mri" },
    { "Marathi", "mar" },
    { "Malay", "msa" },
    { "Malagasy", "mlg" },
    { "Maltese", "mlt" },
    { "Moldavian", "mol" },
    { "Mongolian", "mon" },
    { "Nauru", "nau" },
    { "Navajo", "nav" },
    { "Ndebele, South", "nbl" },
    { "Ndebele, North", "nde" },
    { "Ndonga", "ndo" },
    { "Nepali", "nep" },
    { "Norwegian Nynorsk", "nno" },
    { "Norwegian Bokmål", "nob" },
    { "Norwegian", "nor" },
    { "Chichewa; Nyanja", "nya" },
    { "Occitan", "oci" },
    { "Ojibwa", "oji" },
    { "Oriya", "ori" },
    { "Oromo", "orm" },
    { "Ossetian", "oss" },
    { "Panjabi", "pan" },
    { "Persian", "fas" },
    { "Pali", "pli" },
    { "Polish", "pol" },
    { "Portuguese", "por" },
    { "Pushto", "pus" },
    { "Quechua", "que" },
    { "Romansh", "roh" },
    { "Romanian", "ron" },
    { "Rundi", "run" },
    { "Russian", "rus" },
    { "Sango", "sag" },
    { "Sanskrit", "san" },
    { "Serbian", "srp" },
    { "Croatian", "hrv" },
    { "Sinhala", "sin" },
    { "Slovak", "slk" },
    { "Slovenian", "slv" },
    { "Northern Sami", "sme" },
    { "Samoan", "smo" },
    { "Shona", "sna" },
    { "Sindhi", "snd" },
    { "Somali", "som" },
    { "Sotho, Southern", "sot" },
    { "Spanish", "spa" },
    { "Sardinian", "srd" },
    { "Swati", "ssw" },
    { "Sundanese", "sun" },
    { "Swahili", "swa" },
    { "Swedish", "swe" },
    { "Tahitian", "tah" },
    { "Tamil", "tam" },
    { "Tatar", "tat" },
    { "Telugu", "tel" },
    { "Tajik", "tgk" },
    { "Tagalog", "tgl" },
    { "Thai", "tha" },
    { "Tibetan", "bod" },
    { "Tigrinya", "tir" },
    { "Tonga", "ton" },
    { "Tswana", "tsn" },
    { "Tsonga", "tso" },
    { "Turkmen", "tuk" },
    { "Turkish", "tur" },
    { "Twi", "twi" },
    { "Uighur", "uig" },
    { "Ukrainian", "ukr" },
    { "Urdu", "urd" },
    { "Uzbek", "uzb" },
    { "Venda", "ven" },
    { "Vietnamese", "vie" },
    { "Volapük", "vol" },
    { "Welsh", "cym" },
    { "Walloon", "wln" },
    { "Wolof", "wol" },
    { "Xhosa", "xho" },
    { "Yiddish", "yid" },
    { "Yoruba", "yor" },
    { "Zhuang", "zha" },
    { "Zulu", "zul" },
    {NULL, NULL}
};

static value_map_t vcodec_xlat[] =
{
    {"MPEG-4 (FFmpeg)", "ffmpeg"},
    {"MPEG-4 (XviD)", "ffmpeg"},
    {"H.264 (x264)", "x264"},
    {"VP3 (Theora)", "theora"},
    {NULL,NULL}
};

value_map_t container_xlat[] =
{
    {"MP4 file", "mp4"},
    {"M4V file", "m4v"},
    {"MKV file", "mkv"},
    {"AVI file", "avi"},
    {"OGM file", "ogm"},
    {NULL, NULL}
};

value_map_t framerate_xlat[] =
{
    {"Same as source", "source"},
    {"5", "5"},
    {"10", "10"},
    {"12", "12"},
    {"15", "15"},
    {"23.976", "23.976"},
    {"24", "24"},
    {"25", "25"},
    {"29.97", "29.97"},
    {NULL, NULL}
};

value_map_t deint_xlat[] =
{
    {"0", "none"},
    {"1", "fast"},
    {"2", "slow"},
    {"3", "slower"},
    {NULL, NULL}
};

value_map_t denoise_xlat[] =
{
    {"0", "none"},
    {"1", "weak"},
    {"2", "medium"},
    {"3", "strong"},
    {NULL, NULL}
};

static value_map_t acodec_xlat[] =
{
    {"AAC (faac)", "faac"},
    {"AC3 Passthru", "ac3"},
    {"MP3 (lame)", "lame"},
    {"Vorbis (vorbis)", "vorbis"},
    {NULL,NULL}
};

value_map_t samplerate_xlat[] =
{
    {"Auto", "source"},
    {"22.05", "22.05"},
    {"24", "24"},
    {"32", "32"},
    {"44.1", "44.1"},
    {"48", "48"},
    {NULL, NULL}
};

value_map_t mix_xlat[] =
{
    {"Mono", "mono"},
    {"Stereo", "stereo"},
    {"Dolby Surround", "dpl1"},
    {"Dolby Pro Logic II", "dpl2"},
    {"6-channel discrete", "6ch"},
    {"AC3 Passthru", "none"},
    {NULL, NULL}
};
#endif

typedef struct
{
    gchar *mac_key;
    gchar *lin_key;
    value_map_t *value_map;
    gboolean same;
    gboolean ignore;
} key_map_t;

key_map_t key_map[] = 
{
    {"Audio1Bitrate", NULL, NULL, FALSE, FALSE},
    {"Audio1Encoder", NULL, NULL, FALSE, FALSE},
    {"Audio1Mixdown", NULL, NULL, FALSE, FALSE},
    {"Audio1Samplerate", NULL, NULL, FALSE, FALSE},
    {"Audio1Track", NULL, NULL, FALSE, FALSE},
    {"Audio1TrackDescription", NULL, NULL, FALSE, FALSE},
    {"Audio1TrackDRCSlider", NULL, NULL, FALSE, FALSE},
    {"Audio2Bitrate", NULL, NULL, FALSE, FALSE},
    {"Audio2Encoder", NULL, NULL, FALSE, FALSE},
    {"Audio2Mixdown", NULL, NULL, FALSE, FALSE},
    {"Audio2Samplerate", NULL, NULL, FALSE, FALSE},
    {"Audio2Track", NULL, NULL, FALSE, FALSE},
    {"Audio2TrackDescription", NULL, NULL, FALSE, FALSE},
    {"Audio2TrackDRCSlider", NULL, NULL, FALSE, FALSE},
    {"ChapterMarkers", NULL, NULL, TRUE, FALSE},
    {"Default", NULL, NULL, TRUE, FALSE},
    {"FileFormat", NULL, NULL, TRUE, FALSE},
    {"Folder", NULL, NULL, TRUE, FALSE},
    {"Mp4HttpOptimize", NULL, NULL, TRUE, FALSE},
    {"Mp4iPodCompatible", NULL, NULL, TRUE, FALSE},
    {"Mp4LargeFile", NULL, NULL, TRUE, FALSE},
    {"PictureAutoCrop", NULL, NULL, TRUE, FALSE},
    {"PictureBottomCrop", NULL, NULL, TRUE, FALSE},
    {"PictureDeblock", NULL, NULL, TRUE, FALSE},
    {"PictureDecomb", NULL, NULL, TRUE, FALSE},
    {"PictureDeinterlace", NULL, NULL, TRUE, FALSE},
    {"PictureDenoise", NULL, NULL, TRUE, FALSE},
    {"PictureDetelecine", NULL, NULL, TRUE, FALSE},
    {"PictureHeight", NULL, NULL, TRUE, FALSE},
    {"PictureKeepRatio", NULL, NULL, TRUE, FALSE},
    {"PictureLeftCrop", NULL, NULL, TRUE, FALSE},
    {"PicturePAR", NULL, NULL, TRUE, FALSE},
    {"PictureRightCrop", NULL, NULL, TRUE, FALSE},
    {"PictureTopCrop", NULL, NULL, TRUE, FALSE},
    {"PictureWidth", NULL, NULL, TRUE, FALSE},
    {"PresetDescription", NULL, NULL, TRUE, FALSE},
    {"PresetName", NULL, NULL, TRUE, FALSE},
    {"Subtitles", NULL, NULL, TRUE, FALSE},
    {"SubtitlesForced", NULL, NULL, TRUE, FALSE},
    {"Type", NULL, NULL, TRUE, FALSE},
    {"UsesMaxPictureSettings", NULL, NULL, TRUE, FALSE},
    {"UsesPictureFilters", NULL, NULL, TRUE, FALSE},
    {"UsesPictureSettings", NULL, NULL, TRUE, FALSE},
    {"VFR", NULL, NULL, FALSE, TRUE},
    {"VideoAvgBitrate", NULL, NULL, TRUE, FALSE},
    {"VideoEncoder", NULL, NULL, TRUE, FALSE},
    {"VideoFramerate", NULL, NULL, TRUE, FALSE},
    {"VideoGrayScale", NULL, NULL, TRUE, FALSE},
    {"VideoQualitySlider", NULL, NULL, TRUE, FALSE},
    {"VideoQualityType", NULL, NULL, TRUE, FALSE},
    {"VideoTargetSize", NULL, NULL, TRUE, FALSE},
    {"VideoTwoPass", NULL, NULL, TRUE, FALSE},
    {"VideoTurboTwoPass", NULL, NULL, TRUE, FALSE},
    {"x264Option", NULL, NULL, TRUE, FALSE},
    {NULL, NULL}
};

const gint
key_xlat(key_map_t *key_map, const gchar *mac_key)
{
    gint ii;

    for (ii = 0; key_map[ii].mac_key; ii++)
    {
        if (strcmp(mac_key, key_map[ii].mac_key) == 0)
        {
            if (key_map[ii].ignore)
                return -1;
            return ii;
        }
    }
    g_warning("Unrecognized key: (%s)", mac_key);
    return -1;
}

static GValue*
value_xlat(
    GValue *defaults, 
    key_map_t *key_map, 
    gint key_index, 
    GValue *mac_val)
{
    GValue *gval, *def_val;
    const gchar *lin_key;
    if (key_map[key_index].same)
        lin_key = key_map[key_index].mac_key;
    else
        lin_key = key_map[key_index].lin_key;
    value_map_t *value_map = key_map[key_index].value_map;

    def_val = ghb_dict_lookup(defaults, lin_key);
    if (def_val)
    {
        if (value_map)
        {
            gint ii;
            gchar *str;
            GValue *sval;

            str = ghb_value_string(mac_val);
            for (ii = 0; value_map[ii].mac_val; ii++)
            {
                if (strcmp(str, value_map[ii].mac_val) == 0)
                {
                    sval = ghb_string_value_new(value_map[ii].lin_val);
                    g_free(str);
                    gval = ghb_value_new(G_VALUE_TYPE(def_val));
                    if (!g_value_transform(sval, gval))
                    {
                        g_warning("1 can't transform");
                        ghb_value_free(gval);
                        ghb_value_free(sval);
                        return NULL;
                    }
                    ghb_value_free(sval);
                    return gval;
                }
            }
            g_warning("Can't map value: (%s)", str);
            g_free(str);
        }
        else
        {
            gval = ghb_value_new(G_VALUE_TYPE(def_val));
            if (!g_value_transform(mac_val, gval))
            {
                g_warning("2 can't transform");
                ghb_value_free(gval);
                return NULL;
            }
            return gval;
        }
    }
    else
    {
        g_warning("Bad key: (%s)", lin_key);
        return NULL;
    }
    return NULL;
}

key_map_t audio_key_map[] =
{
    {"Audio1Bitrate", "AudioBitrate", NULL, FALSE, FALSE},
    {"Audio1Encoder", "AudioEncoder", NULL, FALSE, FALSE},
    {"Audio1Mixdown", "AudioMixdown", NULL, FALSE},
    {"Audio1Samplerate", "AudioSamplerate", NULL, FALSE, FALSE},
    {"Audio1Track", "AudioTrack", NULL, FALSE, FALSE},
    {"Audio1TrackDescription", "AudioTrackDescription", NULL, FALSE, FALSE},
    {"Audio1TrackDRCSlider", "AudioTrackDRCSlider", NULL, FALSE, FALSE},
    {"Audio2Bitrate", "AudioBitrate", NULL, FALSE, FALSE},
    {"Audio2Encoder", "AudioEncoder", NULL, FALSE, FALSE},
    {"Audio2Mixdown", "AudioMixdown", NULL, FALSE, FALSE},
    {"Audio2Samplerate", "AudioSamplerate", NULL, FALSE, FALSE},
    {"Audio2Track", "AudioTrack", NULL, FALSE, FALSE},
    {"Audio2TrackDescription", "AudioTrackDescription", NULL, FALSE, FALSE},
    {"Audio2TrackDRCSlider", "AudioTrackDRCSlider", NULL, FALSE, FALSE},
    {NULL, NULL}
};

static void
hard_value_xlat(GValue *lin_dict, const gchar *mac_key, GValue *mac_val)
{
    {
        gint key_index;
        GValue *audio_defaults;

        audio_defaults = ghb_array_get_nth(
            ghb_dict_lookup(defaults, "AudioList"), 0);
        key_index = key_xlat(audio_key_map, mac_key);
        if (key_index >= 0)
        {
            gint audio_index, count, ii;
            GValue *alist, *adict, *val;
            const gchar *lin_key;

            if (audio_key_map[key_index].same)
                lin_key = audio_key_map[key_index].mac_key;
            else
                lin_key = audio_key_map[key_index].lin_key;
            audio_index = mac_key[5] - '1';
            alist = ghb_dict_lookup(lin_dict, "AudioList");
            if (alist == NULL)
            {
                alist = ghb_array_value_new(8);
                ghb_dict_insert(lin_dict, "AudioList", alist);
            }
            count = ghb_array_len(alist);
            for (ii = count; ii <= audio_index; ii++)
            {
                adict = ghb_value_dup(audio_defaults);
                ghb_array_append(alist, adict);
            }
            adict = ghb_array_get_nth(alist, audio_index);
            val = value_xlat(audio_defaults, audio_key_map, key_index, mac_val);
            if (val)
            {
                ghb_dict_insert(adict, g_strdup(lin_key), val);
            }
        }
    }
}

static void
parse_preset_dict(GValue *mac_dict, GValue *lin_dict)
{
    GHashTableIter iter;
    gchar *key;
    GValue *mac_val, *val;

    ghb_dict_iter_init(&iter, mac_dict);
    // middle (void*) cast prevents gcc warning "defreferencing type-punned
    // pointer will break strict-aliasing rules"
    while (g_hash_table_iter_next(
            &iter, (gpointer*)(void*)&key, (gpointer*)(void*)&mac_val))
    {
        gint key_index;

        key_index = key_xlat(key_map, key);
        if (key_index >= 0)
        { // The simple translations
            const gchar *lin_key;

            if (key_map[key_index].same)
                lin_key = key_map[key_index].mac_key;
            else
                lin_key = key_map[key_index].lin_key;
            if (lin_key)
            {
                val = value_xlat(defaults, key_map, key_index, mac_val);
                if (val)
                {
                    ghb_dict_insert(lin_dict, g_strdup(lin_key), val);
                }
            }
            else
            {
                hard_value_xlat(lin_dict, key, mac_val);
            }
        }
    }
}

static void
parse_preset_array(GValue *mac_array, GValue *lin_array)
{
    gint count, ii;
    GValue *mac_dict, *lin_dict, *gval;

    count = ghb_array_len(mac_array);
    for (ii = 0; ii < count; ii++)
    {
        mac_dict = ghb_array_get_nth(mac_array, ii);
        
        // Only process builtin types
        if (ghb_value_int(ghb_dict_lookup(mac_dict, "Type")) != 0)
            continue;

        lin_dict = ghb_dict_value_new();
        ghb_array_append(lin_array, lin_dict);
        gval = ghb_dict_lookup(mac_dict, "PresetName");
        if (gval)
        {
            ghb_dict_insert(lin_dict, g_strdup("PresetName"), 
                            ghb_value_dup(gval));
        }
        gval = ghb_dict_lookup(mac_dict, "PresetDescription");
        if (gval)
        {
            ghb_dict_insert(lin_dict, g_strdup("PresetDescription"), 
                            ghb_value_dup(gval));
        }
        gval = ghb_dict_lookup(mac_dict, "Folder");
        if (gval && ghb_value_boolean(gval))
        { // Folder
            GValue *mval, *lval;

            mval = ghb_dict_lookup(mac_dict, "ChildrenArray");
            lval = ghb_array_value_new(32);
            ghb_dict_insert(lin_dict, g_strdup("ChildrenArray"), lval);
            ghb_dict_insert(lin_dict, g_strdup("Folder"), 
                            ghb_boolean_value_new(TRUE));
            ghb_dict_insert(lin_dict, g_strdup("Type"), 
                            ghb_int_value_new(0));
            parse_preset_array(mval, lval);
        }
        else
        { // Normal preset
            ghb_dict_insert(lin_dict, g_strdup("Type"), 
                            ghb_int_value_new(0));
            parse_preset_dict(mac_dict, lin_dict);
        }
    }
}

static void
xlat(GValue *mac, GValue *lin)
{
    return parse_preset_array(mac, lin);
}

gint
main(gint argc, gchar *argv[])
{
    GValue *mac_plist, *lin_plist;
    GValue *internal;

    if (argc < 3)
    {
        fprintf(stderr, "Usage: <mac plist> <lin plist>\n");
        return 1;
    }
    g_type_init();

    ghb_register_transforms();
    internal = ghb_plist_parse_file("internal_defaults.xml");
    defaults = ghb_dict_lookup(internal, "Presets");
    mac_plist = ghb_plist_parse_file(argv[1]);
    lin_plist = ghb_array_value_new(32);
    xlat(mac_plist, lin_plist);
    ghb_plist_write_file(argv[2], lin_plist);
    return 0;
}