#vorher im anderen projekt jetzt im neuen projekt
#test no string
#test add 1 string
#test adding 2 strings

#add 3 strings
#add 4 strings
#add 6 strings
import unittest
import re
from abc import ABC, abstractmethod
from other.Hatice.feature6 import StringCalculator as Hatice

class CalculatorInterface(ABC):
    @abstractmethod
    def add (self, numbers : str)-> int:
        pass 

class StringCalculator(CalculatorInterface):
    def __init__(self):
        self.called_count = 0
    def add (self, numbers : str)-> int: #Erwartet Integer
        if not numbers:
            return 0
        
        if numbers.startswith("//"):
            delimiter_end_index = numbers.index("\n")
            delimiter_section = numbers[2:delimiter_end_index]
            numbers = numbers[delimiter_end_index +1:]
            
            if delimiter_section.startswith("[")and delimiter_section.endswith("]"):
                delimiters = re.findall(r'\[([^\]]+)\]',delimiter_section)
            else:
                delimiters= [delimiter_section]

            for delimiters in delimiters:
                numbers = numbers.replace(delimiters,",")

        numbers = numbers.replace("\n",",")
            
        number_list = numbers.split(',')#aufteilung der strings
        negative = [] #array für die negativen nummern
        numbers_to_add = []
            #total_sum = 0
        for number_str in number_list: #jedes element in der liste wird durch genommen
                #if number_str:
            number = int(number_str)# summierung der integer
            if number <0:
                negative.append(number)
            elif number > 1000:
                continue
            else:
                numbers_to_add.append(number)
                    #total_sum += number

        if negative:
            print(f"Negative Zahlen:{negative} ")#ausgabe negative zahlen
            raise ValueError(f"negatives not allowed: {','.join(map(str, negative))}")
        self.called_count += 1
        return sum(numbers_to_add)
    def get_called_count(self):
        return self.called_count
        
    
class TestStingCalculator(unittest.TestCase):
    def setUp(self):
        self.calculator = Hatice()     
    def test_empty_string(self):
        self.assertEqual(self.calculator.add(""), 0) #leerer string + 0
    def test_single_number(self):
        self.assertEqual(self.calculator.add("5"),5) #eingabe von einem String
    def test_multiple_numbers(self):
        self.assertEqual(self.calculator.add("5,5"),10)#eingabe mehrere strings
    def test_unknowen_amount_of_numbers(self):
        self.assertEqual(self.calculator.add("1,2,3"),6)
        self.assertEqual(self.calculator.add("10,20,30,40"),100)
        self.assertEqual(self.calculator.add("1,2,3,4,5,6"),21)
    def test_numbers_seperated_by_newline(self):
        self.assertEqual(self.calculator.add("1\n2"),3)
        self.assertEqual(self.calculator.add("1\n2\n3"),6)
        self.assertEqual(self.calculator.add("10,20\n30"),60)

    def test_negative_number_exception(self):

        with self.assertRaises(ValueError) as e:
            self.calculator.add("-1,2")
        self.assertEqual(str(e.exception), "negatives not allowed: -1")
    def test_multiple_negative_numbers_exception(self):
        with self.assertRaises(ValueError)as e:
            self.calculator.add("-1,-2,3")
        self.assertEqual(str(e.exception),"negatives not allowed: -1,-2")
        with self.assertRaises(ValueError) as e:
            self.calculator.add("-1,-3,4")
        self.assertEqual(str(e.exception),"negatives not allowed: -1,-3")

        with self.assertRaises(ValueError) as e:
            self.calculator.add("-1\n-3,4")
        self.assertEqual(str(e.exception),"negatives not allowed: -1,-3")
    def test_add_numbers_with_custom_delimiter(self):
        self.assertEqual(self.calculator.add("//;\n1;2;3"),6)
        self.assertEqual(self.calculator.add("//;\n1,2,3"),6)
        with self.assertRaises(ValueError) as e:
            self.calculator.add("//;\n-3,4")
        self.assertEqual(str(e.exception),"negatives not allowed: -3")
    
    def test_add_numbers_greater_than_1000(self):
        self.assertEqual(self.calculator.add("1,1001,2,3"),6)
    def test_add_numbers_greater_than_1000_1002(self):
        self.assertEqual(self.calculator.add("1002,1,2,3"),6)
    def test_add_numbers_greater_1000_and_minus(self):
        with self.assertRaises(ValueError) as e:
            self.calculator.add("//;\n-3,4;1001")
        self.assertEqual(str(e.exception),"negatives not allowed: -3")
    def test_custom_delimiter(self):
        self.assertEqual(self.calculator.add("//[***]\n1***2***3"),6)
    def test_custom_del(self):
        self.assertEqual(self.calculator.add("//[+++]\n1+++2+++3"),6)
    def test_custom_del2(self):
        self.assertEqual(self.calculator.add("//[aa]\n1aa2aa3"),6)
        
        

if __name__=='__main__':
    unittest.main()