# 4.1

import csv
import re
import os
from prettytable import PrettyTable

MAX_WIDTH = 20
H_RULES = True

dic_naming = \
    {
        'name': 'Название',
        'description': 'Описание',
        'key_skills': 'Навыки',
        'experience_id': 'Опыт работы',
        'premium': 'Премиум-вакансия',
        'employer_name': 'Компания',
        'salary_from': 'Нижняя граница вилки оклада',
        'salary_to': 'Верхняя граница вилки оклада',
        'salary_gross': 'Оклад указан до вычета налогов',
        'salary_currency': 'Идентификатор валюты оклада',
        'area_name': 'Название региона',
        'published_at': 'Дата публикации вакансии',
        'salary': 'Оклад'
    }

dic_currency = \
    {
        "AZN": "Манаты",
        "BYR": "Белорусские рубли",
        "EUR": "Евро",
        "GEL": "Грузинский лари",
        "KGS": "Киргизский сом",
        "KZT": "Тенге",
        "RUR": "Рубли",
        "UAH": "Гривны",
        "USD": "Доллары",
        "UZS": "Узбекский сум"
    }

dic_words = \
    {
        "noExperience": "Нет опыта",
        "between1And3": "От 1 года до 3 лет",
        "between3And6": "От 3 до 6 лет",
        "moreThan6": "Более 6 лет"
    }

dic_gross = \
    {
        "True": "Без вычета налогов",
        "False": "С вычетом налогов"
    }

dic_bool = \
    {
        "False": "Нет",
        "True": "Да"
    }

dic_moneyWord = ["salary_from", "salary_to", "salary_gross", "salary_currency"]


def parse_indexes(number_row: str, count: int) -> list:
    if len(number_row) == 0:
        return [1, count + 1]

    result = number_row.split()

    if len(result) <= 3:
        result.append(count + 1)
    for elem in range(len(result)):
        result[elem] = int(result[elem])

    return result


def parse_headlines(titles_table: str) -> list:
    if len(titles_table) == 0:
        return list()
    result = titles_table.split(', ')
    result.insert(0, '№')
    return result


def is_right_row(row: dict, list_naming: list) -> bool:
    return ((len(row) == len(list_naming)) &
            (not ((None in row) | ("" in row))))


def reverse_number(number: str) -> str:
    final_value: str = ''
    point = number.split('.')[0][::-1]
    count = len(point) // 3 * 3

    for i in range(0, count, 3):
        final_value += ' ' + point[i:i+3]

    if not len(point) % 3 == 0:
        final_value = final_value + ' ' + point[count - len(point):]

    return final_value[::-1][:len(final_value) - 1]


def formatter(current_row: dict) -> dict:
    for elem in current_row:
        if len(current_row[elem]) >= 100:
            current_row[elem] = current_row[elem][:100] + "..."

    format_dict = dict()

    money = f'{reverse_number(current_row["salary_from"])} - {reverse_number(current_row["salary_to"])} ' \
            f'({dic_currency[current_row["salary_currency"]]}) ({dic_gross[current_row["salary_gross"]]})'

    list_time = current_row['published_at'].split('-')
    list_time[2] = list_time[2][0] + list_time[2][1]

    current_row['published_at'] = f'{list_time[2]}.{list_time[1]}.{list_time[0]}'
    current_row['experience_id'] = dic_words[current_row['experience_id']]

    current_row["salary_gross"] = dic_bool[current_row["salary_gross"]]
    current_row["premium"] = dic_bool[current_row["premium"]]

    for headline in current_row:
        if headline == 'salary_from':
            format_dict['salary'] = money

        if headline in dic_moneyWord:
            continue

        format_dict[headline] = current_row[headline]

    return format_dict


def print_vacancies(data_vacancies: list, indexes_row: list,
                    headlines_table: list) -> None:
    start_index, stop_index = indexes_row[0] - 1, indexes_row[1] - 1
    formatted_vacancies_list = list()
    for vacancy in data_vacancies:
        formatted_vacancies_list.append(formatter(vacancy))

    titles_list = list()
    if not len(formatted_vacancies_list) == 0:

        for title in formatted_vacancies_list[0].keys():
            titles_list.append(dic_naming[title])
        titles_list.insert(0, "№")

        table = PrettyTable(titles_list)

        for title in titles_list:
            table._max_width[title] = MAX_WIDTH

        table.hrules = H_RULES
        table.align = "l"

        counter = 1
        for vacancy in formatted_vacancies_list:
            row = list(vacancy.values())
            row.insert(0, counter)
            table.add_row(row)
            counter += 1

        if len(headlines_table) == 0:
            print(table.get_string(start=start_index,
                                   end=stop_index))
        else:
            print(table.get_string(start=start_index,
                                   end=stop_index,
                                   fields=headlines_table))

    else:
        print("Нет данных")


def csv_filer(reader: tuple, list_naming: tuple) -> list:
    vacancies_list = list()
    for vacancy in reader:
        if is_right_row(row=vacancy, list_naming=list_naming):
            for elem in range(0, len(vacancy), 1):
                vacancy[elem] = re.sub(re.compile('<.*?>'), '', vacancy[elem])
                if not elem == 2:
                    vacancy[elem] = ' '.join(vacancy[elem].split())
            vacancies_list.append({k: v for k, v in zip(list_naming, vacancy)})

    return vacancies_list


def csv_reader(csv_name: str) -> tuple:
    with open(csv_name, encoding='utf-8-sig') as file:
        readers = csv.reader(file)
        real_reader = readers.__next__()
        title = [row for row in readers]
        return real_reader, title


file_name = input()
indexes_list = input()
needed_headlines = input()

if not os.stat(file_name).st_size != 0:
    print("Пустой файл")
else:
    raw_reader = csv_reader(csv_name=file_name)
    list_dictionaries = csv_filer(reader=raw_reader[1],
                                  list_naming=raw_reader[0])

    print_vacancies(data_vacancies=list_dictionaries,
                    indexes_row=parse_indexes(indexes_list, len(list_dictionaries)),
                    headlines_table=parse_headlines(needed_headlines))

# 4.2

import sys
import re
import csv
import math
from prettytable import PrettyTable, ALL

HRULES = ALL
ALIGN = 'l'
MAX_WIDTH = 20

headlines_filter = [
    "№", "Название", "Описание", "Навыки", "Опыт работы",
    "Премиум-вакансия", "Компания", "Оклад", "Название региона",
    "Дата публикации вакансии", "Идентификатор валюты оклада"]

headlines_table = [
    "№", "Название", "Описание", "Навыки", "Опыт работы",
    "Премиум-вакансия", "Компания", "Оклад", "Название региона", "Дата публикации вакансии"]

salary_currency = \
    {
        "AZN": "Манаты",
        "BYR": "Белорусские рубли",
        "EUR": "Евро",
        "GEL": "Грузинский лари",
        "KGS": "Киргизский сом",
        "KZT": "Тенге",
        "RUR": "Рубли",
        "UAH": "Гривны",
        "USD": "Доллары",
        "UZS": "Узбекский сум"
    }

experience_translator = \
    {
        "noExperience": "Нет опыта",
        "between1And3": "От 1 года до 3 лет",
        "between3And6": "От 3 до 6 лет",
        "moreThan6": "Более 6 лет"
    }


def get_entered_columns(columns: str) -> list:
    return columns.split(', ') if len(columns) > 3 else headlines_table


def get_filtered_key(key: str) -> str:
    if len(key) == 0:
        return ''
    if not key.count(':'):
        print("Формат ввода некорректен")
        sys.exit()
    if not headlines_filter.count(key.split(':')[0]):
        print("Параметр поиска некорректен")
        sys.exit()
    return key.split(': ')


def get_right_salary_format(slr) -> str:
    return '{:,}'.format(math.floor(float(slr))).replace(',', ' ')


def is_sublist(full_list: list, small_list: list) -> bool:
    counter = 0
    for value in small_list:
        if full_list.count(value):
            counter += 1

    return len(small_list) == counter


def get_filtered_vacancies(vacancies_list: list, keys_for_filtering: list) -> list:
    filtered_vacancies_list = list()
    for vacancy in vacancies_list:
        if filtering[keys_for_filtering[0]](vacancy,
                                            keys_for_filtering[1]):
            filtered_vacancies_list.append(vacancy)
    if len(filtered_vacancies_list) == 0:
        print('Ничего не найдено')
        sys.exit()
    return filtered_vacancies_list


def print_table(vacancies_list: list, columns: list,
                to_end: list) -> None:
    counter = 1
    table = PrettyTable()
    table.hrules = HRULES
    table.align = ALIGN
    table.field_names = headlines_table

    for headlines in table.field_names:
        table.max_width[headlines] = MAX_WIDTH

    for vacancy in vacancies_list:
        array_to_count = [counter]
        for value in headlines_table[1:]:
            temp = formatter[value](vacancy)
            array_to_count.append(temp if len(temp) < 100 else temp[:100] + '...')
        table.add_row(array_to_count)
        counter += 1

    if len(to_end) > 1:
        print(table.get_string(start=to_end[0] - 1, end=to_end[1] - 1, fields=columns))
    elif len(to_end) == 1:
        print(table.get_string(start=to_end[0] - 1, fields=columns))
    else:
        print(table.get_string(fields=columns))


def csv_reader(csv_name: str) -> list:
    with open(csv_name, encoding='utf-8-sig') as read_file:
        file_reader = csv.reader(read_file, delimiter=',')
        vacancies_list = list()
        try:
            titles = next(file_reader)
        except StopIteration:
            print('Пустой файл')
            sys.exit(0)
        for row in file_reader:
            vacancies_list.append(row)
        if len(vacancies_list) == 0:
            print('Нет данных')
            sys.exit(0)
        return [vacancies_list, titles]


def csv_filer(raw_reader: list, headlines: list) -> list:
    vacancies_list = list()
    index_key_skills = headlines.index('key_skills')
    html_tags = re.compile('<.*?>')
    for vacancy in raw_reader:
        try:
            vacancy.remove('')
        except ValueError:
            pass
        for i in range(len(vacancy)):
            if i != index_key_skills:
                vacancy[i] = ' '.join(re.sub(html_tags, '', vacancy[i]).strip().split())
            else:
                vacancy[i] = list(map(lambda x: x.strip(), vacancy[i].split('\n')))

        if len(vacancy) == len(headlines):
            vacancies_list.append({headlines[i]: vacancy[i]
                                   for i in range(len(headlines))})

    return vacancies_list


formatter = \
    {
        'Название': lambda row: row['name'],
        'Описание': lambda row: row['description'],
        'Навыки': lambda row: "\n".join(row['key_skills']),
        'Опыт работы': lambda row: experience_translator[row['experience_id']],
        'Премиум-вакансия': lambda row: 'Да' if row['premium'] == 'True' else 'Нет',
        'Компания': lambda row: row['employer_name'],
        'Оклад': lambda row: f'{get_right_salary_format(row["salary_from"])} - '
                             f'{get_right_salary_format(row["salary_to"])} '
                             f'({salary_currency[row["salary_currency"]]}) '
                             f'({"Без вычета налогов" if row["salary_gross"] == "True" else "С вычетом налогов"})',
        'Название региона': lambda row: row['area_name'],
        'Дата публикации вакансии': lambda row: '.'.join(reversed(row['published_at'][0:10].split('-')))
    }

filtering = \
    {
        'Название': lambda row, key: row['name'] == key,
        'Описание': lambda row, key: row['description'] == key,
        'Навыки': lambda row, key: is_sublist(row['key_skills'], key.split(', ')),
        'Опыт работы': lambda row, key: experience_translator[row['experience_id']] == key,
        'Премиум-вакансия': lambda row, key: ('Да' if row['premium'] == 'True' else 'Нет') == key,
        'Компания': lambda row, key: row['employer_name'] == key,
        'Идентификатор валюты оклада': lambda row, key: salary_currency[row['salary_currency']] == key,
        'Оклад': lambda row, key:
            math.floor(float(row['salary_from'])) <= math.floor(float(key)) <=
            math.floor(float(row['salary_to'])),
        'Название региона': lambda row, key: row['area_name'] == key,
        'Дата публикации вакансии': lambda row, key: '.'.join(reversed(row['published_at'][0:10].split('-'))) == key
    }

file_name = input()
keys_to_filter = get_filtered_key(input())
limits = list(map(lambda x: int(x), input().split()))
needed_columns = get_entered_columns(f'№, {input()}')
reader = csv_reader(csv_name=file_name)
data_vacancies = csv_filer(raw_reader=reader[0],
                           headlines=reader[1])

if len(keys_to_filter) > 0:
    data_vacancies = get_filtered_vacancies(vacancies_list=data_vacancies,
                                            keys_for_filtering=keys_to_filter)

print_table(vacancies_list=data_vacancies,
            columns=needed_columns,
            to_end=limits)