What about millis()?
That isn't affected by month or year changes and is quite accurate (1000 milliseconds is 1 second).

There may be a shorter way to do this, but I've done it the brute-force way (by actually counting the number of days in each month.)  Here's how I did it:

1.   // count the days since the beginning of time
   
2.   void countDays(int yr, int mo, int dy) {
      
       // first, the date in days:
       int leapyears = (int)floor( (yr - 1) / 4 );
       days = yr * 365 + dy + leapyears;
3.     switch(mo) {
         case 12:
           days += 30;
         case 11:
           days += 31;
         case 10:
           days += 30;
         case 9:
           days += 31;
         case 8:
           days += 31;
         case 7:
           days += 30;
         case 6:
           days += 31;
         case 5:
           days += 30;
         case 4:
           days += 31;
         case 3:
           if ( yr % 4 == 0 ) {
             days += 29;
           } else {
             days += 28;
           }
         case 2:
           days += 31;
         case 1:
         break;
       }
     }
   
   

It looks to me that you are trying to measure the number of seconds it took to complete a walk and that the walk may start and end on different days.

Here are 2 possible solutions

Solution 1 - The program is running during the whole walk and is used to mark the start and end times
Instead of using millis() use System.currentTimeMillis() this returns the current time since 1st Jan 1970 in milliseconds using the long data type. This means it will take 28,423,602 years to roll over.

Solution 2 - Historic calculation where the user types in the start and end date/time and the computer calculates the difference between them. To do that you can use the Java class GregorianCalendar like this

1. GregorianCalendar gcNow, gcBefore;
2. long  elapsedTime;
3. 
   
4. public void setup() {
5.   size(300, 300);
6.   // This will get the current data and time
   
7.   gcNow = new GregorianCalendar();
8.   // This will calculate another date/time based on parameters
   
9.   //  Parameters are                y    m   d  h   m   s
   
10.   gcBefore = new GregorianCalendar(2000, 1, 22, 17, 30, 20);
11.   // Calculate the elapsed time in milliseconds
    
12.   elapsedTime = gcNow.getTimeInMillis() - gcBefore.getTimeInMillis();
13.   // Display the number of seconds elapsed
    
14.   println("Time elapsed " + elapsedTime/1000 + " seconds");
15. }

HTH

You could also add a check, too see if millis() has overflown.

System.currentTimeMillis() is long?  If I can access it, it will directly solve my problem.

In Processing you can use

1. System.currentTimeMillis();

as a direct replacement for

1. millis();