ListOfLists

program ListOfLists2;

uses
  crt;

type
  pSubListItem = ^TSubListItem;
  TSubListItem = record
    info : integer;
    next : pSubListItem;
  end;
  pSubList = ^TSubList;
  TSubList = record
    pFirst : pSubListItem;
    pNext : pSubList;
    number : integer;
  end;

var
  mList, pTempMain : pSubList;
  pTemp : pSubListItem;
  countOfSubLists, i, ii, element : integer;
  answer, answer2, answer3 : byte;

procedure whileOutput(pTempL : pSubListItem);
begin
  while (pTempL <> nil) do
  begin
    write(pTempL^.info);
    pTempL := pTempL^.next;
    if (pTempL = nil) then break;
    write(' ');
  end;
end;

procedure correctList;
begin
  pTempMain := mList;
  i := 1;
  while (pTempMain <> nil) do
  begin
    pTempMain^.number := i;
    inc(i);
    pTempMain := pTempMain^.pNext;
  end;
end;

procedure output;
var
  pTemp : pSubListItem;
  pTempMain : pSubList;
begin
  textBackground(10);
  write('  ');
  normVideo;
  writeln('Current list:');
  pTempMain := mList;
  while (pTempMain <> nil) do
  begin
    pTemp := pTempMain^.pFirst;
    write(pTempMain^.number, ' sublist: [');
    while (pTemp <> nil) do
    begin
      write(pTemp^.info);
      pTemp := pTemp^.next;
      if (pTemp = nil) then
      begin
        break;
      end;
      write(' ');
    end;
    writeln(']');
    pTempMain := pTempMain^.pNext;
  end;
end;

procedure outputSubList(subListNumber : integer);
var
  pTempMain : pSubList;
  pTemp : pSubListItem;
begin                                              // [22 33]
  pTempMain := mList;
  while (pTempMain^.number <> subListNumber) do
  begin
    pTempMain := pTempMain^.pNext;
  end;
  pTemp := pTempMain^.pFirst;
  write(pTempMain^.number, ' sublist: [');
  while (pTemp <> nil) do
  begin
    write(pTemp^.info);
    pTemp := pTemp^.next;
    if (pTemp = nil) then break;
    write(' ');
  end;
  writeln(']');
end;

function back(ans : integer) : boolean;
begin
  if (ans = 11) then back := true else back := false;
end;

//procedure addAfter(ans, element : integer);
//var
//  pTempPrev : pSubListItem;
//  afterElement : integer;
//begin
//  new(pTemp);
//  pTemp^.info := element;
//  if (mArray[ans]^.pFirst = nil) then
//  begin
//    pTemp^.next := nil;
//    mArray[ans]^.pFirst := pTemp;
//  end else                // ans sublist: [22 33 11 55]
//  begin
//    write('  Enter the element after which add new element: ');
//    readln(afterElement);
//    pTempPrev := mArray[ans]^.pFirst;
//    while (pTempPrev^.info <> afterElement) do
//    begin
//      pTempPrev := pTempPrev^.next;
//    end;
//    if (pTempPrev^.next <> nil) then pTemp^.next := pTempPrev^.next;
//    pTempPrev^.next := pTemp;
//  end;
//end;

procedure createSubList;
var
  number : integer;
  pTempMain, pTemp : pSubList;
begin
  new(pTemp);
  pTempMain := mList;
  output;
  write('  After which sublist create new sublist(number of sublist)?: ');
  textColor(10);
  readln(number);
  normVideo;
  pTemp^.number := number;
  pTemp^.number += 1;                                    // 1 2 3 4
  while (pTempMain^.number <> number) do                 // 1
  begin
    pTempMain := pTempMain^.pNext;
  end;
  pTemp^.pNext := pTempMain^.pNext;
  pTempMain^.pNext := pTemp;
  pTemp^.pFirst := nil;
  correctList;
end;


procedure addElementToSublist(ans : integer);
var
  oldElement : integer;
  pTempMain : pSubList;
  pTemp, pTempHelp : pSubListItem;
begin
  new(pTemp);
  write('  Enter the new element: ');
  textColor(10);
  readln(pTemp^.info);
  normVideo;
  pTempMain := mList;
  while (pTempMain^.number <> ans) do
  begin
    pTempMain := pTempMain^.pNext;
  end;
  if (pTempMain^.pFirst = nil) then pTempMain^.pFirst := pTemp else
  begin
    pTempHelp := pTempMain^.pFirst;
    if (pTempHelp^.next = nil) then
    begin
      pTempHelp^.next := pTemp;
    end else
    begin
      write('  After which element add new element?: ');
      textColor(10);
      readln(oldElement);
      normVideo;
      while (pTempHelp^.info <> oldElement) do
      begin
        pTempHelp := pTempHelp^.next;
      end;
      pTemp^.next := pTempHelp^.next;
      pTempHelp^.next := pTemp;
    end;
  end;
end;

procedure disintegration;
var
  pTempMain : pSubList;
begin
  pTempMain := mList;
  while (pTempMain <> nil) do
  begin
    pTempMain^.pFirst := nil;
    pTempMain := pTempMain^.pNext;
  end;
end;

procedure remove(ans : integer);
var
  pTemp, pTempHelp : pSubListItem;
  element : integer;
  pTempMain : pSubList;
begin
  write('  Enter the element to remove: ');
  textColor(10);
  readln(element);
  normVideo;
  pTempMain := mList;
  while (pTempMain^.number <> ans) do
  begin
    pTempMain := pTempMain^.pNext;
  end;
  pTemp := pTempMain^.pFirst;
  pTempHelp := pTemp;
  while (pTemp^.info <> element) do
  begin
    pTempHelp := pTemp;
    pTemp := pTemp^.next;                         // [22 33] 55 66 11]
  end;
  pTempHelp^.next := pTemp^.next;
  if (pTemp = pTempMain^.pFirst) then
  begin
    pTempMain^.pFirst := pTempMain^.pFirst^.next;
  end else
  begin
    pTempHelp^.next := pTempHelp^.next^.next;
  end;
end;

begin
  new(mList);
  mList^.pFirst := nil;
  mList^.pNext := nil;
  mList^.number := 1;
  repeat
  begin
    writeln('1. Create new sublist');
    writeln('2. Change the exist sublist');
    writeln('3. Disintegration');
    writeln('4. Output');
    writeln('11. Exit');
    textColor(11);
    readln(answer);
    normVideo;
    case answer of
      1:
      begin
        createSubList;
        output;
      end;
      2:
      begin
        repeat
          output;
          write('  Which sublist do you want to change?: ');
          textColor(10);
          readln(answer2);
          normVideo;
          outputSubList(answer2);
          writeln('1. Add elements to sublist');
          writeln('2. Remove elements from sublist');
          writeln('3. Remove sublist');
          writeln('11. Back');
          textColor(11);
          readln(answer3);
          normVideo;
          case answer3 of
            1:
            begin
              addElementToSubList(answer2);
            end;
            2:
            begin
              remove(answer2);
            end;
            3:
            begin
              pTempMain := mList;
              while (pTempMain^.number <> answer2) do
              begin
                pTempMain := pTempMain^.pNext;
              end;
              pTempMain^.pFirst := nil;
            end;
          end;
        until (back(answer3) or back(answer2));
      end;
      3:
      begin
        disintegration;
      end;
      4:
      begin
        output;
      end;
    end;
  end until back(answer);
end.