program program_peliculas;
uses cmem, crt, sysutils;

type Comparable = function (const datum1 : pointer; const datum2 : pointer) : integer;
type ForEachFunction = procedure (datum : pointer; params : pointer);

type Pelicula = object
    codigo_de_barras : string;
    titulo : string;
    genero : string;
    clasificacion : char;
    ano : integer;
    idioma : char;
end;
type pPelicula = ^Pelicula;

function compare_pelicula (const pelicula1 : pPelicula; const pelicula2 : pPelicula) : integer;
begin
    compare_pelicula := strcomp (@pelicula1^.codigo_de_barras[1], @pelicula2^.codigo_de_barras[1]);
end;

function read_str (message : string) : string;
var string_var : string;
begin
    write (stdout, message, ': ');
    readln (string_var);
    read_str := string_var;
end;

function read_integer (message : string) : integer;
var integer_var : integer;
begin
    write (stdout, message, ': ');
    readln (integer_var);
    read_integer := integer_var;
end;

function read_character (message : string) : char;
var char_var : char;
begin
    write (stdout, message, ': ');
    readln (char_var);
    read_character := char_var;
end;

function read_field (var file_stream : text; var field : string) : boolean;
var c : char;
begin
    field := '';
    while not eof (file_stream) do
    begin
        read (file_stream, c);
        if (c=#13) then
            continue;
        if (c=#9) or (c=#10) then
        begin
            read_field := true;
            exit;
        end
        else
            field := field + c;
    end;
    read_field := false;
end;

type pinteger = ^integer;
procedure print_pelicula (datum : pPelicula; counter : pinteger);
begin
    writeln (stdout, 'codigo de barras: ', datum^.codigo_de_barras);
    writeln (stdout, 'titulo          : ', datum^.titulo);
    writeln (stdout, 'genero          : ', datum^.genero);
    writeln (stdout, 'clasificacion   : ', datum^.clasificacion);
    writeln (stdout, 'ano             : ', datum^.ano);
    writeln (stdout, 'idioma          : ', datum^.idioma);
    writeln (stdout);
    inc (counter^);
end;

type pText = ^text;
procedure print_on_file (datum : pPelicula; file_stream : pText);
begin
    write (file_stream^, datum^.codigo_de_barras, #9);
    write (file_stream^, datum^.titulo, #9);
    write (file_stream^, datum^.genero, #9);
    write (file_stream^, datum^.clasificacion, #9);
    write (file_stream^, datum^.ano, #9);
    write (file_stream^, datum^.idioma, #10);
end;

type ppointer = ^pointer;
type ppPelicula = ^pPelicula;

function array_insert (array_var : ppointer; var length : integer; datum : pointer) : ppointer;
begin
    array_var := realloc (array_var, sizeof (pointer) * (length+1));
    array_var[length] := datum;
    inc (length);
    array_insert := array_var;
end;

function array_search (array_var : ppointer; length : integer; compare: Comparable; const datum : pointer) : pointer;
begin
    if length > 0 then
        if compare (array_var[0], datum) = 0 then
            array_search := array_var[0]
        else
            array_search := array_search (array_var + 1, length - 1, compare, datum)
    else
        array_search := nil;
end;

function array_remove (array_var : ppointer; var length : integer; const datum : pointer) : ppointer;
var i : integer = 0;
begin
    while (i<length) and (datum<>array_var[i]) do
        inc (i);
    if i<length then
        begin
            for i:=i+1 to length-1 do
                array_var[i-1] := array_var[i];
            dec (length);
            array_var := realloc (array_var, sizeof (pointer) * length);
        end;
    array_remove := array_var;
end;

procedure quick_sort (array_var : ppointer; first_index : integer; last_index : integer; compare: Comparable);
var smaller, bigger : integer;
var pivot : pointer;
begin
    smaller := first_index;
    bigger := last_index;
    if last_index>first_index then
        begin
            pivot := array_var[(first_index+last_index) div 2];
            while smaller <= bigger do
                begin
                    while (smaller < last_index) and (compare (array_var[smaller], pivot)<0) do
                        inc (smaller);
                    while (bigger > first_index) and (compare (array_var[bigger], pivot)>0) do
                        dec (bigger);
                    if smaller <= bigger then
                        begin
                            pivot := array_var[smaller];
                            array_var[smaller] := array_var[bigger];
                            array_var[bigger] := pivot;
                            inc (smaller);
                            dec (bigger);
                        end;
                end;
            if first_index < bigger then
                quick_sort (array_var, first_index, bigger, compare);
            if smaller < last_index then
                quick_sort (array_var, smaller, last_index, compare);
        end;
end;

procedure array_foreach (array_var : ppointer; length : integer; params : pointer; func : ForEachFunction);
begin
    if length>0 then
        begin
            func (array_var[0], params);
            array_foreach (array_var + 1, length - 1, params, func);
        end;
end;

const path = 'peliculas.tsv';
var datum : ^Pelicula = nil;
var pelicula1 : Pelicula;
var main_option : char;
var counter, suboption : integer;
var field : string = '';
var file_stream : text;
var peliculas : ppPelicula = nil;
var length : integer = 0;
begin
    counter := 0;
    if fileexists (path) then
    begin
        assign (file_stream, path);
        reset (file_stream);
        while read_field (file_stream, field) do
        begin
            new (datum);
            datum^.codigo_de_barras := field;
            read_field (file_stream, field);
            datum^.titulo := field;
            read_field (file_stream, field);
            datum^.genero := field;
            read_field (file_stream, field);
            datum^.clasificacion := field;
            read_field (file_stream, field);
            val (field, datum^.ano);
            read_field (file_stream, field);
            datum^.idioma := field;
            peliculas := ppPelicula (array_insert (ppointer (peliculas), length, datum));
        end;
        close (file_stream);
    end;
    repeat
        clrscr;
        writeln (stdout, 'MEN'#233#10#13);
        writeln (stdout, '1.- Altas');
        writeln (stdout, '2.- Consultas');
        writeln (stdout, '3.- Actualizaciones');
        writeln (stdout, '4.- Bajas');
        writeln (stdout, '5.- Ordenar registros');
        writeln (stdout, '6.- Listar registros');
        writeln (stdout, '7.- Salir');
        write (stdout, 'Selecciona una opci'#162'n: ');
        repeat
            main_option := readkey;
        until (main_option>='1') and (main_option<='7');
        writeln (stdout, main_option, #10#13);
        if (peliculas = nil) and (main_option <> '1') and (main_option <> '7') then
        begin
            write (stdout, 'No hay registros.'#10#13#10#13'Presiona una tecla para continuar . . . ');
            readkey;
            continue;
        end;
        if main_option<'5' then
        begin
            pelicula1.codigo_de_barras := read_str ('Ingresa el codigo de barras del pelicula');
            datum := array_search (ppointer (peliculas), length, Comparable(@compare_pelicula), @pelicula1);
            if datum <> nil then
            begin
                writeln (stdout);
                print_pelicula (datum, @counter);
            end;
        end;
        if (main_option = '1') and (datum <> nil) then
            writeln (stdout, 'El registro ya existe.')
        else if (main_option>='2') and (main_option<='4') and (datum = nil) then
            writeln (stdout, #10#13'Registro no encontrado.')
        else case main_option of
            '1':
                begin
                    new (datum);
                    datum^.codigo_de_barras := pelicula1.codigo_de_barras;
                    datum^.titulo := read_str ('Ingresa el titulo');
                    datum^.genero := read_str ('Ingresa el genero');
                    datum^.clasificacion := read_character ('Ingresa el clasificacion');
                    datum^.ano := read_integer ('Ingresa el ano');
                    datum^.idioma := read_character ('Ingresa el idioma');
                    peliculas := ppPelicula (array_insert (ppointer (peliculas), length, datum));
                    writeln (stdout, #10#13'Registro agregado correctamente.');
                end;
            '3':
                begin
                    writeln (stdout, 'Men'#163' de actualizaci'#162'n de campos');
                    writeln (stdout, '1.- titulo');
                    writeln (stdout, '2.- genero');
                    writeln (stdout, '3.- clasificacion');
                    writeln (stdout, '4.- ano');
                    writeln (stdout, '5.- idioma');
                    repeat
                        suboption := read_integer ('Selecciona el n'#163'mero de campo a modificar');
                            if (suboption<1) or (suboption>5) then
                        writeln (stdout, 'Opci'#162'n incorrecta');
                    until (suboption>=1) and (suboption<=5);
                    case suboption of
                        1: datum^.titulo := read_str ('Ingresa el nuevo titulo');
                        2: datum^.genero := read_str ('Ingresa el nuevo genero');
                        3: datum^.clasificacion := read_character ('Ingresa el nuevo clasificacion');
                        4: datum^.ano := read_integer ('Ingresa el nuevo ano');
                        5: datum^.idioma := read_character ('Ingresa el nuevo idioma');
                    end;
                    writeln (stdout, #10#13'Registro actualizado correctamente.');
                end;
            '4':
                begin
                    peliculas := ppPelicula (array_remove (ppointer (peliculas), length, datum));
                    dispose (datum);
                    writeln (stdout, 'Registro eliminado correctamente.');
                end;
            '5':
                begin
                    quick_sort (ppointer (peliculas), 0, length - 1, Comparable(@compare_pelicula));
                    writeln (stdout, 'Registros ordenados correctamente.');
                end;
            '6':
                begin
                    counter := 0;
                    array_foreach (ppointer (peliculas), length, @counter, ForEachFunction (@print_pelicula));
                    writeln (stdout, 'Total de registros: ', counter, '.');
                end;
        end;
        if (main_option<'7') then
        begin
            write (stdout, #10#13'Presiona una tecla para continuar . . . ');
            readkey;
        end;
    until main_option = '7';
    assign (file_stream, path);
    rewrite (file_stream);
    array_foreach (ppointer (peliculas), length, @file_stream, ForEachFunction (@print_on_file));
    close (file_stream);
end.