From b9fc858709cb39d4c23259e8a2b6a4401a0698a8 Mon Sep 17 00:00:00 2001
From: Stephan Porada <porada@posteo.de>
Date: Wed, 17 Mar 2021 12:37:54 +0100
Subject: [PATCH] Final commit

---
 palindrome.py          | 14 ++++++++----
 transform/Transform.py | 52 +++++++++++++++++++++++++++++++++++++++---
 2 files changed, 59 insertions(+), 7 deletions(-)

diff --git a/palindrome.py b/palindrome.py
index 848b164..e255d35 100644
--- a/palindrome.py
+++ b/palindrome.py
@@ -13,19 +13,25 @@ def parse_args():
                                                   'palindrome'))
     parser.add_argument('-i',
                         '--int',
-                        nargs=1,
                         required=True,
                         help='The integer to be transformed.',
                         type=int)
+    # NOTE: The argument must be an integer. Because of this constrain integers
+    # with leading zeroes will be stripped automatically in python 3.
     args = parser.parse_args()
     return args
 
 
 def main():
     args = parse_args()
-    print(args.int)
-    print(Transform.palindrome(args.int))
-    return args
+    if args.int <= 10000 and args.int > 0:
+        print('Input integer is: {}'.format(args.int))
+        transform = Transform()
+        palindrome = transform.palindrome(args.int)
+        print("Final Output is:", palindrome)
+        return palindrome
+    else:
+        print("Input integer is not betweent 1 and 10000")
 
 
 if __name__ == '__main__':
diff --git a/transform/Transform.py b/transform/Transform.py
index 12a3432..ac926bc 100644
--- a/transform/Transform.py
+++ b/transform/Transform.py
@@ -6,6 +6,52 @@ class Transform(object):
     def __init__(self):
         super(Transform, self).__init__()
 
-    @staticmethod
-    def palindrome(int):
-        return int
+    def palindrome(self, int):
+        '''
+        Kind of the main function. Checks if input int is already a palindrome
+        and trys calculation one if input integer is not already a palindrome.
+        '''
+        self.input_int = int
+        if self.__is_palindrome(self.input_int):
+            print('Integer {} is a palindrome'.format(self.input_int))
+            return self.input_int
+        else:
+            print('Integer {} is not a palindrome'.format(self.input_int))
+            print('Calculating the palindrome for input {}'.format(self.input_int))
+            palindrome = self.__calculate_palindrome()
+            return palindrome
+
+    # The following methods are private. Signaled by the leading __
+    def __is_palindrome(self, int_to_check):
+        reversed = self.__reverese_int(int_to_check)
+        if self.input_int == reversed:
+            return True
+        else:
+            return False
+
+    def __reverese_int(self, int_to_reverse):
+        reversed = 0
+        int_to_check = int_to_reverse
+        while int_to_check > 0:
+            reminder = int_to_check % 10
+            reversed = (reversed * 10) + reminder
+            int_to_check = int_to_check // 10
+        return reversed
+
+    def __calculate_palindrome(self):
+        reversed = self.__reverese_int(self.input_int)
+        self.input_int = self.input_int + reversed
+        print('Possible palindrome is {}'.format(self.input_int))
+
+        if self.__is_palindrome(self.input_int) is True:
+            return self.input_int
+
+        if self.__is_palindrome(self.input_int) is False:
+            return self.__try_again()
+
+    def __try_again(self):
+        while self.input_int <= 1000000000:
+            self.__calculate_palindrome()
+            if self.input_int >= 1000000000:
+                print('Palindrome to be calculated is to big. Abort!')
+        return -1