import re
_proposal_regex = r'(?:(?:(IKE|ESP):)?[\w/]+(?:/NO_EXT_SEQ)?(?:, ?(IKE|ESP):[\w/]+(?:/NO_EXT_SEQ)?)*)?'
_proposals_re = rf'(?P<proposals>{_proposal_regex}|)'
pattern = rf'received proposals: {_proposals_re}'
match = re.match(pattern, 'received proposals: ')
print(match.group('proposals') if match else "No match")  # Prints "No match"

""" Currency Converter
----------------------------------------
"""
import urllib.request
import json
def currency_converter(currency_from, currency_to, currency_input):
    yql_base_url = "https://query.yahooapis.com/v1/public/yql"
    yql_query = 'select%20*%20from%20yahoo.finance.xchange%20where%20pair' \
                '%20in%20("'+currency_from+currency_to+'")'
    yql_query_url = yql_base_url + "?q=" + yql_query + "&format=json&env=store%3A%2F%2Fdatatables.org%2Falltableswithkeys"
    try:
        yql_response = urllib.request.urlopen(yql_query_url)
        try:
            json_string = str(yql_response.read())
            json_string = json_string[2:
            json_string = json_string[:-1]
            print(json_string)
            yql_json = json.loads(json_string)
            last_rate = yql_json['query']['results']['rate']['Rate']
            currency_output = currency_input * float(last_rate)
            return currency_output
        except (ValueError, KeyError, TypeError):
            print(yql_query_url)
            return "JSON format error"
    except IOError as e:
        print(str(e))
currency_input = 1
#currency codes : http://en.wikipedia.org/wiki/ISO_4217
currency_from = "USD"
currency_to = "TRY"
rate = currency_converter(currency_from, currency_to, currency_input)
print(rate)

def format_timestamp(timestamp_epoch):
    """
    Convert epoch timestamp to formatted datetime string without using datetime package.
    
    Args:
        timestamp_epoch (int/float): Unix epoch timestamp (seconds since 1970-01-01 00:00:00 UTC)
        
    Returns:
        str: Formatted datetime string in 'YYYY-MM-DD HH:MM:SS' format
    """
    # Constants for time calculations
    SECONDS_PER_DAY = 86400
    SECONDS_PER_HOUR = 3600
    SECONDS_PER_MINUTE = 60
    
    # Handle negative timestamps and convert to integer
    timestamp = int(timestamp_epoch)
    
    # Calculate days since epoch and remaining seconds
    days_since_epoch = timestamp // SECONDS_PER_DAY
    remaining_seconds = timestamp % SECONDS_PER_DAY
    
    # Calculate hours, minutes, seconds
    hours = remaining_seconds // SECONDS_PER_HOUR
    remaining_seconds %= SECONDS_PER_HOUR
    minutes = remaining_seconds // SECONDS_PER_MINUTE
    seconds = remaining_seconds % SECONDS_PER_MINUTE
    
    # Calculate date (simplified, ignoring leap seconds)
    year = 1970
    days = days_since_epoch
    while days >= 365:
        is_leap = (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)
        days_in_year = 366 if is_leap else 365
        if days >= days_in_year:
            days -= days_in_year
            year += 1
    
    # Month lengths (non-leap year for simplicity, adjusted later for leap years)
    month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
        month_lengths[1] = 29
    
    month = 0
    while days >= month_lengths[month]:
        days -= month_lengths[month]
        month += 1
    
    # Convert to 1-based indexing for month and day
    month += 1
    day = days + 1
    
    # Format the output string
    return f"{year:04d}-{month:02d}-{day:02d} {hours:02d}:{minutes:02d}:{seconds:02d}"

# Example timestamp (Unix epoch seconds)
timestamp = 1697054700
formatted_date = format_timestamp(timestamp)
print(formatted_date + " UTC")  # Output: 2023-10-11 18:45:00

prime_lists=[] # a list to store the prime numbers

def prime(n): # define prime numbers
    if n <= 1:
        return False
    # divide n by 2... up to n-1
    for i in range(2, n):
        if n % i == 0:  # the remainder should'nt be a 0
            return False
    else:
        prime_lists.append(n)
        return True



for n in range(30,1000):  # calling function and passing starting point =30 coz we need primes >30
    prime(n)

check=0 # a var to limit the output  to 10 only
for n in prime_lists:
    for x in prime_lists:
        val=  n *x
        if (val > 1000 ):
            check=check +1
        if (check <10) :
            print("the num is:", val , "=",n , "* ", x )
        break

#question1.py
def rose(n) :
  if n==0 : 
    yield []
  else :
    for k in range(0,n) :    
      for l in rose(k) :
        for r in rose(n-1-k) :      
            yield [l]+[r]+[r]
            
def start(n) :
  for x in rose(n) : 
      print(x) #basically I am printing x for each rose(n) file


print("starting program: \n")
start(2) # here is where I call the start function

class Solution(object):
    def floodFill(self, image, sr, sc, newColor):
        R, C = len(image), len(image[0])
        color = image[sr][sc]
        if color == newColor: return image
        def dfs(r, c):
            if image[r][c] == color:
                image[r][c] = newColor
                if r >= 1: dfs(r-1, c)
                if r+1 < R: dfs(r+1, c)
                if c >= 1: dfs(r, c-1)
                if c+1 < C: dfs(r, c+1)

        dfs(sr, sc)
        return image