program laba2_3;

uses
   System.SysUtils;

Type
   TArray = array of array of real;

procedure PrintTask; forward;
function InputValue(Min, Max: Integer): Integer; forward;
procedure UserInputArrayFromConsole(n: Integer); forward;
procedure UserInputFromConsole(); forward;
procedure UserInputFromFile(MyFile: TextFile); forward;
function CheckPath(Path: String): Boolean; forward;
function UserOutputPath(): String; forward;
function Gauss(Matrix: TArray):TArray; forward;
procedure PrintWithoutPath(Matrix: TArray); forward;
procedure PrintWithPath(Matrix: TArray); forward;
function CheckFile(MyFile: TextFile): Boolean; forward;
procedure UserInputPath(); forward;
procedure InputMethod; forward;
procedure OutputMethod(Matrix: TArray); forward;

function InputValue(Min, Max: Integer): Integer;
var
   CurrentValue: Integer;
   IsValid: Boolean;
begin
   repeat
   IsValid := True;
   try
      Read(CurrentValue);
   except
      begin
         IsValid := False;
         Writeln('Введите число');
      end;
   end;
   if IsValid then
      if (CurrentValue < Min) or (CurrentValue > Max) then
      begin
         IsValid := False;
         Writeln('Введите число в заданном диапазоне');
      end;
   until IsValid;
   CheckInput := CurrentValue;
end;

procedure UserInputArrayFromConsole(n: Integer);
var
   i, j: Integer;
   Matrix: TArray;
   const MIN_VALUE = -500;
   const MAX_VALUE = 500;
begin
   Writeln('Введите коэффициенты в диапазоне ', MIN_VALUE, '..', MAX_VALUE);
   SetLength(Matrix, n);
   for i := 0 to n - 1 do
   begin
      SetLength(Matrix[i], n + 1);
      for j := 0 to n - 1 do
         Matrix[i][j] := CheckInput(MIN_VALUE, MAX_VALUE);
   end;
   Readln;
   Writeln('Введите свободные члены в диапазоне ', MIN_VALUE, '..', MAX_VALUE);
   for i := 0 to n - 1 do
     Matrix[i, n] := CheckInput(MIN_VALUE, MAX_VALUE);
   Readln;
   OutputMethod(Gauss(Matrix));
end;

procedure UserInputFromConsole();
var
   n: Integer;
   const MIN_SIZE = 2;
   const MAX_SIZE = 20;
begin
   Write('Введите порядок матрицы в диапазоне ', MIN_SIZE, '..', MAX_SIZE, ': ');
   N := CheckInput(MIN_SIZE, MAX_SIZE);
   Readln;
   UserInputArrayFromConsole(n);
end;

procedure UserInputFromFile(MyFile: TextFile);
var
   i, j, n: Integer;
   Matrix: TArray;
begin
   Readln(MyFile, n);
   SetLength(Matrix, n);
   for i := 0 to n - 1 do
   begin
      SetLength(Matrix[i], n + 1);
      for j := 0 to n -1 do
         Read(MyFile, Matrix[i, j]);
   end;
   for i := 0 to n - 1 do
      Read(MyFile, Matrix[i, n]);
   closefile(MyFile);
   OutputMethod(Gauss(Matrix));
end;

function CheckPath(Path: String): Boolean;
begin
   if FileExists(Path) then
   begin
      Writeln(Path, ' существует');
      CheckPath := True;
   end
   else
   begin
      Writeln(Path, ' не существует');
      Writeln('Введите корректный путь к файлу');
   end;
end;

function UserOutputPath(): String;
var
   Path: String;
begin
   Writeln('Введите абсолютный путь к файлу для вывода результата');
   Readln(Path);
   UserOutputPath := Path;
end;

function Gauss(Matrix: TArray): TArray;
var
   i, j, N1, n, k: Integer;
   Temp: Real;
begin
   n := length(Matrix);
   for k := 0 to n - 1 do
      for j := k + 1 to n - 1 do
      begin
         Temp := Matrix[j][k] / Matrix[k][k];
         for i := k to n - 1 do
            Matrix[j][i] := Matrix[j][i] - Temp * Matrix[k][i];
         Matrix[j][n] := Matrix[j][n] - Temp * Matrix[k][n];
      end;
   Gauss := Matrix;
end;

procedure PrintWithoutPath(Matrix: TArray);
var
   i, j: Integer;
begin
   Writeln('После «прямого хода»');
   for i := 0 to Length(Matrix) - 1 do
   begin
      for j := 0 to Length(Matrix[i]) - 2 do
         Write(Matrix[i][j], ' ');
      Writeln;
   end;
   for i := 0 to Length(Matrix) - 1 do
      Writeln(Matrix[i,Length(Matrix[i]) - 1]);
   Writeln('Нажмите Enter для выхода из программы');
   Readln;
end;

procedure PrintWithPath(Matrix: TArray);
var
   i, j: Integer;
   MyFile: TextFile;
begin
   assignfile(MyFile,UserOutputPath);
   rewrite(MyFile);
   for i := 0 to Length(Matrix) - 1 do
   begin
      for j := 0 to Length(Matrix[i]) - 1 do
         Write(MyFile, Matrix[i][j], ' ');
      Writeln(MyFile);
   end;
   close(MyFile);
   Writeln('Результат работы помещён в файл');
end;

function CheckFile(MyFile: TextFile): Boolean;
var
   IsValid: Boolean;
   n, i, j: Integer;
   a: real;
   const MIN_SIZE = 1;
   const MAX_SIZE = 20;
   const MIN_VALUE = -500;
   const MAX_VALUE = 500;
begin
   IsValid := True;
   try
      Read(MyFile, n);
   except
      IsValid := False;
   end;
   if IsValid then
      if (n < MIN_SIZE) or (n > MAX_SIZE) then
         IsValid := False;
   while (IsValid) and (i < n) do
   begin
      inc(i);
      j := 0;
      while (IsValid) and (j < n) do
      begin
         inc(j);
         try
            Read(MyFile,a);
         except
            IsValid := False;
         end;
         if IsValid then
            if (a < MIN_VALUE) or (a > MAX_VALUE) then
               IsValid := False;
      end;
   end;
   CheckFile := IsValid;
end;

procedure UserInputPath();
var
   Path: String;
   MyFile: TextFile;
begin
   repeat
      repeat
         Writeln('Введите абсолютный путь к файлу с входными данными');
         Readln(Path);
      until CheckPath(Path);
      AssignFile(MyFile, path);
      reset(MyFile);
      if not(CheckFile(MyFile)) then
         Writeln('Неккоректные данные в файле, исправьте файл');
      reset(MyFile);
   until (CheckFile(MyFile));
   reset(MyFile);
   UserInputFromFile(MyFile);
end;

procedure InputMethod;
var
   Method: String;
begin
   Writeln('Каким способом хотите ввести данные?');
   Writeln('1 - с помощью консоли');
   Writeln('2 - с помощью файла');
   repeat
   Readln(Method);
   case Method of
   '1': UserInputFromConsole;
   '2': UserInputPath;
   else
      Writeln('Введите корректный способ ввода');
   end;
   until (Method = '1') or (Method = '2');
end;

procedure OutputMethod(Matrix: TArray);
var
   Method: String;
begin
   Writeln('Куда хотите вывести результат?');
   Writeln('1 - в консоль');
   Writeln('2 - в файл');
   repeat
   Readln(Method);
   case Method of
   '1': PrintWithoutPath(Matrix);
   '2': PrintWithPath(Matrix);
   else
      Writeln('Введите корректный способ вывода');
   end;
   until (Method = '1') or (Method = '2');
end;

procedure PrintTask;
begin
   Writeln('Данная программа выполняет «прямой ход» в решении системы линейных алгебраических уравнений методом Гаусса');
end;

begin
   PrintTask;
   InputMethod;
end.