#include <iostream>
#include <cstring>

using namespace std;
class Date{
int dd,mm, yy;
public:
   Date(int d=1,int m=1,int g=1900){
        dd=d;
        mm=m;
        yy=g;
    }
    static int compare(Date d1,Date d2){
        if(d1.yy<d2.yy)       return 1;
        else if (d1.yy>d2.yy) return -1;
        else if (d1.mm<d2.mm) return 1;
        else if (d1.mm>d2.mm) return -1;
        else if (d1.dd<d2.mm) return 1;
        else if (d1.dd>d2.dd) return -1;
        else return 0;
    }
    int getDay() const{
        return dd;
    }
    int getMonth()const{
        return mm;
    }
    int getYear()const{
        return yy;
    }
};

class InvalidAccountNumber{
private:
    char *invalidID;
    char *passedMessage;
public:
    InvalidAccountNumber(char *invalidID,char *passedMessage){
        this->invalidID=invalidID;
        this->passedMessage=passedMessage;
    }
    void message(){
        cout<<passedMessage<<endl;
    }
};

class Transaction{
private:
    char *name;
    char ID[16];
    float transactionValue;
    Date date;
public:

    Transaction(char *name,char*ID,float transactionValue,Date date){
        this->transactionValue=transactionValue;
        strcpy(this->name,name);
        validateFormat(ID);
        validateLen(ID);
        strcpy(this->ID,ID);
        this->date=date;
    }

    void validateFormat(char*ID){
        int k=0;
        while(ID[k]!='\0')
            if(isdigit(ID[k])==0)
                throw new InvalidAccountNumber(ID,"Non-digit account number format");
            else
                k++;
    }

    void validateLen(char*ID){
        int len=0;
        int k=0;
        while(ID[k]!='\0'){
            if(isdigit(ID[k])!=0)
                len++;
            k++;
        }
        if(len!=15)
            throw new InvalidAccountNumber(ID,"Error in the number of chars");
    }

    Transaction(const Transaction &t1){
        transactionValue=t1.transactionValue;
        strcpy(name,t1.name);
        strcpy(ID,t1.ID);
        date=t1.date;
    }

    Transaction& operator=(Transaction &t1){
        if(this!=&t1){
            delete[]name;
            transactionValue=t1.transactionValue;
            strcpy(name,t1.name);
            strcpy(ID,t1.ID);
            date=t1.date;
        }
        return *this;
    }

    friend ostream& operator<<(ostream &out,const Transaction &t1)
    {
        if(t1.transactionValue<0)
            out<<"Outflow ";
        else
            out<<"Inflow ";

        out<<t1.transactionValue<<" "<<t1.name<<"(";
        for(int i=0;i<16;i++)
            out<<t1.ID[i];
        out<<")-"<<t1.date.getDay()<<"."<<t1.date.getMonth()
        <<"."<<t1.date.getYear()<<endl;
        return out;
    }

    float getBalance(){
        return transactionValue;
    }

    bool getFlow(){
        return transactionValue>0;
    }

    Date getDate(){
        return date;
    }
};

void trySort(Transaction **transactions,int N){
    for(int i=0;i<N-1;i++)
    for(int j=i+1;j<N;j++){
        if(Date::compare(transactions[i]->getDate(),transactions[j]->getDate())==-1){
            Transaction *t=transactions[i];
            transactions[i]=transactions[j];
            transactions[j]=t;
        }
    }
}

class TransactionAccount{
private:

    char *name;
    char ID[16];
    Transaction**transactions;
    int numberOfTransactions;
    int transactionCapacity;
public:
    TransactionAccount(char *name,char *ID){
        strcpy(this->name,name);
        strcpy(this->ID,ID);
        numberOfTransactions=0;
        transactionCapacity=3;
        transactions=new Transaction*[transactionCapacity];
    }
    TransactionAccount(){
        numberOfTransactions=0;
        transactionCapacity=3;
        transactions=new Transaction*[transactionCapacity];
    }

    TransactionAccount(const TransactionAccount &t1){
        strcpy(name,t1.name);
        strcpy(ID,t1.ID);
        numberOfTransactions=t1.numberOfTransactions;
        transactionCapacity=t1.transactionCapacity;
        transactions=new Transaction*[transactionCapacity];
        for(int i=0;i<numberOfTransactions;i++)
            transactions[i]=t1.transactions[i];
    }
    TransactionAccount& operator=(const TransactionAccount &t1){
        if(this!=&t1){
            delete[]*transactions;
            strcpy(name,t1.name);
        strcpy(ID,t1.ID);
        numberOfTransactions=t1.numberOfTransactions;
        transactionCapacity=t1.transactionCapacity;
        transactions=new Transaction*[transactionCapacity];
        for(int i=0;i<numberOfTransactions;i++)
            transactions[i]=t1.transactions[i];
        }
        return *this;
    }

    void addTransaction(Transaction &t){
        if(numberOfTransactions==transactionCapacity){
            transactionCapacity*=2;
            Transaction **transactionTemp=new Transaction*[transactionCapacity];
            for(int i=0;i<numberOfTransactions;i++)
                transactionTemp[i]=transactions[i];

            transactionTemp[numberOfTransactions++]=&t;
            delete[]*transactions;
            transactions=transactionTemp;
        }else{
            transactions[numberOfTransactions++]=&t;
        }
    }

    void reportTransaction(Date from,Date to,bool isInflow){
        Transaction **transactionTemp=new Transaction*[transactionCapacity];
        int k=0;
        for(int i=0;i<numberOfTransactions;i++){
                if(Date::compare(transactions[i]->getDate(),from)==-1&&
                   Date::compare(transactions[i]->getDate(),to)==1){
                    if(isInflow){
                            if(transactions[i]->getFlow())
                            transactionTemp[k++]=transactions[i];
                    }else
                        transactionTemp[k++]=transactions[i];
            }
        }

        trySort(transactionTemp,numberOfTransactions);
        for(int i=0;i<k;i++)
            cout<<transactionTemp[i];
    }

    float getBalance(){
        float total=0;
        for(int i=0;i<numberOfTransactions;i++)
            total+=transactions[i]->getBalance();
        return total;
    }

    int getTransCapacity(){
        return transactionCapacity;
    }

    int getTransNumber(){
        return numberOfTransactions;
    }

    Transaction** getTransList(){
        return transactions;
    }

};

int main(){

char name[50],number[16];
float amount;
int d,m,y;
int n;
bool isInflow;
TransactionAccount ta;
int testcase;
cin>>testcase;

switch (testcase){
  case 1:
     {
      cout<<"------Transaction test------"<<endl;
      cin>>name;
      cin>>number;
      cin>>amount;
      cin>>d>>m>>y;
      Transaction t(name,number,amount,Date(d,m,y));
      cout<<t;
     }
      break;
  case 2:
      {cout<<"------TransactionAccount test:constructor, desctuctor & get-functions------"<<endl;
      cin>>name;
      cin>>number;
      TransactionAccount ta(name,number);
      cin>>n;
      for (int j=0;j<n;j++)
      {

          cin>>name>>number>>amount>>d>>m>>y;
          Transaction t(name,number,amount,Date(d,m,y));
          ta.addTransaction(t);
      }
      cout<<"Capacity: "<<ta.getTransCapacity()<<endl;
      cout<<"Number of elements: "<<ta.getTransNumber()<<endl;
      cin>>n;
      cout<<"The element on position "<<n<<" is "<<endl;
      cout<<(ta.getTransList())[n];
      }  break;
  case 3:
      {cout<<"------TransactionAccount: getSaldo------"<<endl;
      cin>>name;
      cin>>number;
      TransactionAccount ta(name,number);
      cin>>n;
      for (int j=0;j<n;j++)
      {

          cin>>name>>number>>amount>>d>>m>>y;
          Transaction t(name,number,amount,Date(d,m,y));
          ta.addTransaction(t);

      }
      cout<<"Balance: "<<ta.getBalance()<<endl;
      }  break;
  case 4:
      {cout<<"------TransactionAccount: reportTransaction & Exception------"<<endl;
      cin>>name;
      cin>>number;
      ta=TransactionAccount(name,number);
      cin>>n;
      for (int j=0;j<n;j++)
      {
          try{
          cin>>name>>number>>amount>>d>>m>>y;
          Transaction t(name,number,amount,Date(d,m,y));
          ta.addTransaction(t);
          }
          catch (InvalidAccountNumber e){
              e.message();
          }
      }
      cin>>d>>m>>y;
      Date d1(d,m,y);
      cin>>d>>m>>y;
      Date d2(d,m,y);
      cin>>isInflow;
      ta.reportTransaction(d1,d2,isInflow);
      }  break;

};

return 0;
}