program lab2_4;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils;
type
    MatrixType = array of array of integer;
    MassType = array of integer;

function IsMatrixCorrect(FileName: string): boolean;
var
    FileIn: TextFile;
    Sign: Integer;
    CorrectMatrix: boolean;
begin
    CorrectMatrix := true;
    AssignFile(FileIn, FileName);
    reset(FileIn);
    while (not EOF(FileIn)) do
    begin
        try
            read(FileIn, Sign)
        except
            CorrectMatrix := false
        end;
    end;
    CloseFile(FileIn);
    IsMatrixCorrect := CorrectMatrix;
end;

function MatrixRowSize(FileName: string): integer;
var
    FileIn: TextFile;
    Count: integer;
begin
    Count := 0;
    AssignFile(FileIn, FileName);
    reset(FileIn);
    while (not EOF(FileIN)) do
    begin
        readln(FileIn);
        inc(Count);
    end;
    CloseFile(FileIn);
    MatrixRowSize := Count;
end;

function MatrixColSize(FileName: string): integer;
var
    FileIn: TextFile;
    Count, Sign: integer;
begin
    Count := 0;
    AssignFile(FileIn, FileName);
    reset(FileIn);
    while (not EOln(FileIN)) do
    begin
        read(FileIn, Sign);
        inc(Count);
    end;
    CloseFile(FileIn);
    MatrixColSize := Count;
end;

function FileNameInputRead(): string;
var
    isCorrect: boolean;
    FileName: string;
begin
    isCorrect := false;
    repeat
        writeln('Enter file name:');
        readln(FileName);
        if FileExists(FileName) then
            if IsMatrixCorrect(FileName) then
                if MatrixRowSize(FileName) = MatrixColSize(FileName) then
                    isCorrect := true
                else
                    writeln('Matrix must be of order n!')
            else
                writeln('There are unallowable symbols in file!')
        else
            writeln('This file does not exist!');
    until isCorrect;
    FileNameInputRead := FileName;
end;

function FileNameOutputRead(): string;
var
    FileName: string;
    isCorrect: boolean;
    i: integer;
begin
    isCorrect := false;
    repeat
        writeln('Enter the file name for output:');
        readln(FileName);
        for i := 1 to length(FileName) do
            if FileName[i] <> ' ' then
                isCorrect := true;
        if not isCorrect then
            writeln('Empty string entered!');
    until isCorrect;
    if not(ExtractFileExt(FileName) = '.txt') then
        FileName := FileName + '.txt';
    FileNameOutputRead := FileName;
end;

function FileExistProc(): integer;
var
    Sign: string;
    isCorrect: boolean;
begin
    writeln('This file already exists! Enter 1 to rewrite or 2 to create new name:');
    repeat
        begin
            readln(Sign);
            isCorrect := true;
            if sign = '1' then
                FileExistProc := 1
            else
                if sign = '2' then
                    FileExistProc := 2
                else
                    begin
                        isCorrect := false;
                        writeln('You must enter 1 to rewrite or 2 to create new name! Try
                            again:');
                    end;
        end
    until isCorrect;
end;
function FileNameForOutput(): string;
var
    FileOut: TextFile;
    FileName: string;
    isCorrect: boolean;
begin
    FileName := FileNameOutputRead();
    if FileExists(FileName) then
    repeat
        isCorrect := true;
        if (FileExistProc() = 2) then
        begin
            FileName := FileNameOutputRead();
            if FileExists(FileName) then
                isCorrect := false;
        end;
    until isCorrect;
    FileNameForOutput := FileName;
end;

procedure MatrixOutput(const Matrix: MatrixType; Row, Col: integer);
var
    i, j: integer;
begin
    for i := 0 to Row do
    begin
        for j := 0 to Col do
            write(Matrix[i, j], ' ');
        writeln;
    end;
    writeln;
end;

procedure ReadFromFile(var Matrix: MatrixType; FileName : string; Row, Col: integer);
var
    FileIn: TextFile;
    i, j: integer;
begin
    AssignFile(FileIn, FileName);
    reset(FileIn);
    while (not EOF(FileIN)) do
    for i := 0 to Row do
        for j := 0 to Col do
            read(FileIn, Matrix[i, j]);
    CloseFile(FileIn);
end;

procedure WriteToFile(const Matrix: MatrixType; FileName : string; Row, Col: integer);
var
    FileOut: TextFile;
    i, j: integer;
begin
    AssignFile(FileOut, FileName);
    rewrite(FileOut);
    for i := 0 to Row do
    begin
        for j := 0 to Col do
        begin
            write(FileOut, Matrix[i, j]);
            write(FileOut, '    ');
        end;
    writeln(FileOut, ' ');
    end;
    CloseFile(FileOut);
    writeln('Saved to file: ', FileName);
end;

procedure MatrixLineCorrect(var Matrix: MatrixType; Row, Col: integer);
var
    j, Sign: integer;
begin
    for j := 0 to Col do
    begin
        Sign := Matrix[Row + 1, j];
        Matrix[Row + 1, j] := Matrix[Row, j];
        Matrix[Row, j] := Sign;
    end;
end;

procedure NumbersOfZeroCorrect(var NumbersOfZero: array of integer; CurrentCol: integer);
var
    k: integer;
begin
    k := NumbersOfZero[CurrentCol + 1];
    NumbersOfZero[CurrentCol + 1] := NumbersOfZero[CurrentCol];
    NumbersOfZero[CurrentCol] := k;
end;

procedure MatrixZeroCount(var NumbersOfZero: array of integer; Matrix: MatrixType; Row,
    Col:integer);
var
  i, j, count: Integer;
begin
    count := 0;
    for i := 0 to Row do
    begin
        for j := 0 to Col do
            if matrix[i, j] = 0 then
                inc(count);
        NumbersOfZero[i] := count;
        count := 0;
    end;

end;

procedure MatrixZeroCorrect (Matrix:MatrixType; Row, Col: integer);
var
    i, j: integer;
    NumbersOfZero: array of integer;
begin
    Setlength(NumbersOfZero, Row + 1);
    MatrixZeroCount(NumbersOfZero, Matrix, Row, Col);
    Row := Row - 1;
    for i := 0 to Row do
        for j := 0 to Row - i do
            if NumbersOfZero[j] > NumbersOfZero[j + 1] then
            begin
                NumbersOfZeroCorrect(NumbersOfZero, j);
                MatrixlineCorrect(Matrix, j, Col);
            end;
    writeln;
end;


var
    Matrix: MatrixType;
    Row, Col, Sign, i: integer;
    FileNameIn, FileNameOut: string;

begin
    FileNameIn := FileNameInputRead();
    Row := MatrixRowSize(FileNameIn);
    Col := MatrixColSize(FileNameIn);
    SetLength(Matrix, Row, Col);
    dec(Row);
    dec(Col);
    ReadFromFile(Matrix, FileNameIn, Row, Col);
    writeln;
    writeln('Initial matrix:');
    MatrixOutput(Matrix, Row, Col);
    MatrixZeroCorrect(Matrix, Row, Col);
    writeln('Finished matrix:');
    MatrixOutput(Matrix, Row, Col);
    writeln;
    FileNameOut := FileNameForOutput();
    WriteToFile(Matrix, FileNameOut, Row, Col);
    readln;
end.