# TODO: use this everywhere

def parse_financial_bracket(start, end):

def parse_financial_bracket(text):
    [start, end] = text.split("-")

        # Extract the median rent (midpoint between range) for each column
        median_rents = self.median_rents()
        # Extract the median household income (midpoint between each range) for each bracket
        median_incomes = self.median_incomes()
        # Extract the actual table
        population_data = self.population_data()
        from pprint import pprint
        pprint(population_data)

        return (start_ranges, end_ranges)

        brackets = []
        for bracket in range(len(start_ranges)):
            brackets.append(start_ranges[bracket] + end_ranges[bracket])
        return brackets

        (start_ranges, end_ranges) = self.filter_rent_brackets()

        brackets = self.filter_rent_brackets()

        rents = []
        for column in range(len(start_ranges)):
            start = start_ranges[column]
            end = end_ranges[column]

        rents = {}
        for bracket in range(len(brackets)):
            (start, end) = parse_financial_bracket(brackets[bracket])
            median_rent = (start + end + 1) // 2

            # Strip hypen suffix from `start`
            start = start[:-1]

            # Total population is sum of column
            total_population = 0
            for row in self.filter_income_brackets():
                total_population += int(row[bracket + 1])

            (start, end) = parse_financial_bracket(start, end)
            rents.append((start + end + 1) // 2)

            rents[median_rent] = total_population

        rows = self.POPULATION_BY_INCOME.splitlines()

        rows = tabulate(self.POPULATION_BY_INCOME)

        assert rows[0].startswith("Negative income")
        assert rows[1].startswith("Nil income")
        assert rows[-3].startswith('"$2,000 or more"')
        assert rows[-2].startswith("Partial income stated(a)")
        assert rows[-1].startswith("All incomes not stated(b)")

        assert rows[0][0] == "Negative income"
        assert rows[1][0] == "Nil income"
        assert rows[-3][0] == "$2000 or more"
        assert rows[-2][0] == "Partial income stated(a)"
        assert rows[-1][0] == "All incomes not stated(b)"

        rows = rows[2:-3]

        return rows[2:-3]

        return rows

        incomes = []

        incomes = {}

            # Two dollar amounts separated by a hyphen ('-')
            # row[0] will be values such as: '$1-$39'
            [start, end] = row[0].split("-")

            (start, end) = parse_financial_bracket(row[0])
            median_rent = (start + end + 1) // 2

            # Make sure we've got data in the right shape
            assert start.startswith("$")
            assert end.startswith("$")
            assert should_keep(row[0])
            # Strip prefixes
            start = start[1:]
            end = end[1:]
            # Downcast and calculate midpoint
            start = int(start)
            end = int(end)
            incomes.append((start + end + 1) // 2)

            # The last column is a 'total' amount
            population = int(row[-1])
            incomes[median_rent] = population

        brackets = []
        for row in rows:
            brackets.append(row[0])
        return brackets

        return rows

        median_rents = {}

            [start, end] = rents[rent].split("-")
            (start, end) = parse_financial_bracket(start, end)

            (start, end) = parse_financial_bracket(rents[rent][0])

            rents[rent] = (start + end + 1) // 2

            median_rent = (start + end + 1) // 2
            total_population = int(rents[rent][-1])

        return rents

            median_rents[median_rent] = total_population
        return median_rents

        incomes = []
        for row in rows:
            incomes.append(row[0])

        return rows

        return incomes

        median_incomes = {}

            [start, end] = incomes[income].split("-")
            (start, end) = parse_financial_bracket(start, end)

            (start, end) = parse_financial_bracket(incomes[income][0])

            incomes[income] = (start + end + 1) // 2

            median_income = (start + end + 1) // 2
            total_population = int(incomes[income][-1])
            median_incomes[median_income] = total_population

        return incomes

        return median_incomes

# data = Census1996()

data = Census2001().median_incomes()

print(Census1996().median_incomes())
print(Census1996().median_rents())
print(Census2001().median_incomes())
print(Census2001().median_rents())