var types = [];
var interfaces = [];
var methods = [];

var typeMapping = {
    'Boolean': 'bool',
    'True': 'bool',
    'Integer': 'int',
    'Integer64': 'int64',
    'Float': 'float64',
    'String': 'string',
};

var typeRewrites = {
    'LoginUrl': 'LoginURL',
}

function typePostProcess(str) {
    if (typeRewrites.hasOwnProperty(str)) {
        return typeRewrites[str];
    }

    return str;
}

function underBarToUpperCamel(str) {
    return str.split('_').map(function (s) {
        if (s === 'id') {
            return 'ID';
        }

        if (s === 'url') {
            return 'URL';
        }

        return s.charAt(0).toUpperCase() + s.slice(1)
    }).join('');
}

function underbarToCamel(str) {
    var res = underBarToUpperCamel(str);

    return res.charAt(0).toLowerCase() + res.slice(1);
}

function resolveType(type, description) {
    if (type.includes('InlineKeyboardMarkup')) {
        return '*ReplyMarkup';
    }

    if (type.includes('InputFile')) {
        return '*InputFile';
    }

    if (type.includes('Float')) {
        return 'float64';
    }

    if (description.includes('64 bit integer')) {
        type = 'Integer64';
    }

    if (type.includes('Array of Array of')) {
        var arrayType = /Array of Array of (.+)/.exec(type)[1];
        if (typeMapping.hasOwnProperty(arrayType)) {
            return '[][]' + typeMapping[arrayType];
        }

        return '[][]*' + typePostProcess(arrayType);
    }

    if (type.includes('Array of ')) {
        var arrayType = /Array of (.+)/.exec(type)[1];
        if (typeMapping.hasOwnProperty(arrayType)) {
            return '[]' + typeMapping[arrayType];
        }

        return '[]*' + typePostProcess(arrayType);
    }

    if (typeMapping.hasOwnProperty(type)) {
        return typeMapping[type];
    }

    return '*' + typePostProcess(type);
}

function handleMethod(elem) {
    var elems = elem.nextUntil('h3, h4');
    var rows = elems.filter('table').find('tbody tr');
    var name = elem.text();
    var params = [];

    for (var i = 0; i < rows.length; i++) {
        var row = $(rows[i]);
        var cols = $(row.find('td'));
        var param = $(cols[0]).text();
        var type = $(cols[1]).text();
        type = resolveType(type, '');

        params.push({
            name: underbarToCamel(param),
            json: param,
            type: type,
        });
    }

    methods.push({
        name: name,
        params: params,
    });
}

function handleConcreteType(elem, rows) {
    var name = typePostProcess(elem.text());
    var typeDesc = elem.next('p').text();
    var fields = [];

    for (var i = 0; i < rows.length; i++) {
        var row = $(rows[i]);
        var cols = $(row.find('td'));
        var field = $(cols[0]).text();
        var type = $(cols[1]).text();
        var description = $(cols[2]).text();
        type = resolveType(type, description);

        fields.push({
            name: typePostProcess(underBarToUpperCamel(field)),
            json: field,
            type: type,
        });
    }

    types.push({
        name: name,
        description: typeDesc,
        fields: fields,
        interface: '',
    });
}

function handleInterface(elem, list) {
    var name = typePostProcess(elem.text());
    var iterfaceDesc = elem.next('p').text();
    var interfaceTypes = [];

    for (var i = 0; i < list.length; i++) {
        var item = $(list[i]);
        var type = item.text();

        interfaceTypes.push({
            name: typePostProcess(type),
        });
    }

    interfaces.push({
        name: name,
        description: iterfaceDesc,
        types: interfaceTypes,
    });
}

function handleType(elem) {
    var elems = elem.nextUntil('h3, h4');
    var list = elems.filter('ul').find('li');
    var rows = elems.filter('table').find('tbody tr');
    if (list.length > 0) {
        handleInterface(elem, list);
    } else {
        handleConcreteType(elem, rows);
    }
}

// Collect types, interfaces and methods

var headers = $('.anchor').parent().filter('h4');

interfaces.push({
    name: 'ReplyMarkup',
    description: 'This object represents reply markup.',
    types: [],
});

for (var i = 0; i < headers.length; i++) {
    var header = $(headers[i]);
    var headerText = header.text();
    if (headerText.length === 0 || headerText.includes(" ")) {
        continue;
    }

    if (headerText[0] === headerText[0].toUpperCase()) {
        handleType(header);
    } else {
        handleMethod(header);
    }
}

// Set type interfaces

for (var i = 0; i < types.length; i++) {
    var type = types[i];
    for (var j = 0; j < interfaces.length; j++) {
        var interface = interfaces[j];
        var stop = false;
        for (var subtype of interface.types) {
            if (type.name === subtype.name) {
                types[i].interface = interface.name;
                stop = true;
                break;
            }
        }

        if (stop) {
            break;
        }
    }
}

var schema = {
    types: types,
    interfaces: interfaces,
    methods: methods,
}

var interfaceLines = [];

for (const interface of interfaces) {
    interfaceLines.push('// ' + interface.name + ' - ' + type.description + "\n");
    interfaceLines.push('type ' + interface.name + ' interface {' + "\n");
    interfaceLines.push('   ' + interface.name + '()' + "\n");
    interfaceLines.push('}' + "\n\n");
}

var typeLines = [];

for (const type of types) {
    typeLines.push('// ' + type.name + ' - ' + type.description + "\n");
    typeLines.push('type ' + type.name + ' struct {' + "\n");
    for (const field of type.fields) {
        typeLines.push('    ' + field.name + ' ' + field.type + ' `json:"' + field.json + '"`' + "\n");
    }
    typeLines.push('}' + "\n\n");
}

var golangCode = interfaceLines.join('') + typeLines.join('');

console.log(golangCode);