from common import format_timestamp
import json
import textwrap

def wrap_text(text):
    return textwrap.fill(text, 80,
        replace_whitespace=False,
        break_on_hyphens=False,
        break_long_words=False)


def generate_godword(value):
    return f"{' '.join(value[:10])}\n{' '.join(value[10:])}"

def generate_habits(value):
    return '\n'.join(f'[{"x" if v else "-"}] {k}' for k,v in value.items())

def generate_notifications(value):
    return '\n'.join(f'[[{n["source"]}]] {n["message"]}' for n in value)

def generate_tasks(value):
    return '\n'.join(f'[{"x" if v else "-"}] {k}' for k,v in value.items())

header_modules = {
    'godword': generate_godword,
    'habits': generate_habits,
    'notifications': generate_notifications,
    'tasks': generate_tasks,
}

def generate_diet(block):
    _, amount, food = block.values()
    return f'@diet {amount}g {food}'

def generate_exercise(block):
    if block['kind'] == 'walk':
        return f'@exercise walk {block["minutes"]}min {block["distance"]}km {block["steps"]}steps'
    elif block['kind'] == 'calisthenics':
        return f'@exercise calisthenics {block["sets"]}x{block["reps"]} {block["exercise"]}'

    assert False

def generate_default(block):
    return f'@{block["type"]} {block["value"]}'

def generate_post(block):
    result = '@post'

    if ts := block.get('timestamp'):
        result += f' {format_timestamp(ts)}'
    
    if content := block.get('content'):
        result += f' {content}'
    
    return wrap_text(result)

def generate_timer(block):
    parts = [f'@{block["type"]}']

    if name := block.get('name'):
        parts.append(name)

    if ts := block.get('timestamp'):
        parts.append(format_timestamp(ts))

    return ' '.join(parts)

def generate_info(block):
    return wrap_text(f'@info {block["value"]}')

def generate_notes(block):
    parts = ['@notes']

    if source := block.get('source'):
        parts.append(source)
    if title := block.get('title'):
        parts.append(title)

    return '\n'.join(parts)

def generate_notify(block):
    return f'@notify {block["day"]} {block["message"]}'

entry_modules = {
    'diet': generate_diet,
    'exercise': generate_exercise,
    'hide': lambda _: '@hide',
    'post': generate_post,
    'info': generate_info,
    'notes': generate_notes,
    'behavior': generate_default,
    'task': generate_default,
    'start': generate_timer,
    'stop': generate_timer,
    'done': generate_timer,
    'notify': generate_notify,
}

def generate_page(day, header, entries):
    result = f'# {day}'

    for name, value in header.items():
        result += f'\n\n{name.title()}:\n'
        result += header_modules[name](value)

    def format_block(block, is_first):
        def format_text(text):
            if all(c == '\n' for c in block):
                return text

            DUMMY_TS = '2020-02-02 02:02:02 '

            if is_first:
                text = DUMMY_TS + text

            length = len(text)
            
            if length > 80:
                text = wrap_text(text)
            
            if is_first:
                text = text.removeprefix(DUMMY_TS)
            
            return text
        
        def format_module(module):
            return entry_modules[module['type']](module)
        
        formatted = format_text(block) if isinstance(block, str) else format_module(block)

        if result[-1] != '\n' and not all(c == '\n' for c in formatted):
            formatted = ' ' + formatted
        
        return formatted
        
    for entry in entries:
        result += f'\n\n{format_timestamp(entry["timestamp"])}' 
        for i, block in enumerate(entry['blocks']):
            result += format_block(block, i == 0)
    
    result += '\n'

    return result

if __name__ == '__main__':
    journal = json.load(open('journal.json'))

    for curr_day in journal:
        header, entries = journal[curr_day].values()
        page = generate_page(curr_day, header, entries)
        print(page)