#!/usr/bin/env python3
# Copyright 2024 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
r"""
Generates code/header skeletons for coordinator, coordinator configuration,
coordinator delegate, mediator, view controller, presentation delegate,
consumer, mutator and BUILD file. It can be called piecemeal with different
parameters to add a new component to existing files. Note that it will create
all related files, even if they are are not asked for. For example adding
a consumer will automatically update/create the view controller and mediator.
BUILD.gn file is always added or updated, regardless of parts selected.
This script should be run from chromium root src folder.
Example:

cmvc --out ios/chrome/browser/ui/choose_from_drive --cm ChooseFromDrive c m

Will create the `out` folder if needed then generate or update:
choose_from_drive_coordinator.h
choose_from_drive_coordinator.mm
choose_from_drive_coordinator_delegate.h
choose_from_drive_mediator.h
choose_from_drive_mediator.mm

cmvc --out ios/chrome/browser/ui/choose_from_drive --cm ChooseFromDrive \
  --vc FilePicker cons

Will add:

file_picker_consumer.h
file_picker_view_controller.h
file_picker_view_controller.mm

And update:

choose_from_drive_mediator.h
choose_from_drive_mediator.mm

Note: As usual it is suggested to backup, or be ready to do a git revert, on
the destination folder before running this script.
Note: Adding a configuration to an existing coordinator is not handled.
It would need updating the designated initializer with adding the configuration.
The configuration file skeleton will still be created, however.

"""

import argparse
import os
import re
import subprocess
import sys

# Character to set colors in terminal.
TERMINAL_ERROR_COLOR = "\033[1m\033[91m"
TERMINAL_INFO_COLOR = "\033[22m\033[92m"
TERMINAL_RESET_COLOR = "\033[0m"

# Static obj-c match regular expressions.
SNAKE_CASE_RE = re.compile(r"(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])")
IMPORT_RE = re.compile(r"^#import\s")
FORWARDS_RE = re.compile(r"^(@class|@protocol|class|enum)\s+([A-Za-z0-9_]+);$")
OBJC_TYPE_START_RE = re.compile(r"^@(?:interface|protocol)\s+")
OBJC_TYPE_RE = re.compile(
    r"^@(interface|protocol)\s+([A-Za-z0-9_]+)[\s\n]+"
    r"(:[\s\n]*([A-Za-z0-9_]+))?[\s\n]*"
    r"(<[\s\n]*(,?[\s\n]*[A-Za-z0-9_]+[\s\n]*)+>)?[\s\n]*$")
END_RE = re.compile(r"^@end$")
PROPERTY_START_RE = re.compile(r"^@property\s*\(")
PROPERTY_RE = re.compile(
    r"^@property\s*(\([^\)]+\))[\s\n]*([a-zA-Z<>_,]+)[\s\n]*([a-zA-Z0-9_]+);$")
METHOD_START_RE = re.compile(r"^[-+]\s\(")
METHOD_H_END_RE = re.compile(r";$")
METHOD_HEAD_MM_RE = re.compile(r"^([-+]\s*[^{]+)")
IMPLEMENTATION_HEAD_RE = re.compile(
    r"^@implementation\s+([A-Za-z0-9_]+)\s*([{])?$")
IMPLEMENTATION_BLOCK_END_RE = re.compile(r"^}$")
PRAGMA_MARK_RE = re.compile(r"^#pragma\smark\s(-\s+)?(.+)$")
IVARS_RE = re.compile(r"^\s+(.+)\s+(.+);$")

GN_SOURCE_SET_START_RE = re.compile(r'^source_set\(\"([^\"]+)\"\)\s+{$')
GN_SOURCE_SET_END_RE = re.compile(r'^}$')
GN_BLOCK_ONE_LINE_RE = re.compile(
    r'^  (sources|deps|frameworks)\s*=\s*\[\s*\"([^\"]+)\"\s*\]$')
GN_BLOCK_START_RE = re.compile(r'^  (sources|deps|frameworks)\s*=\s*\[$')
GN_ITEM_RE = re.compile(r'^    \"([^\"]+)\",$')
GN_BLOCK_END_RE = re.compile(r'  \]$')

# Set to True for verbose output
DEBUG = False


def adapted_color_for_output(color_start, color_end):
    """Returns a the `color_start`, `color_end` tuple if the output is a
    terminal, or empty strings otherwise"""
    if not sys.stdout.isatty():
        return "", ""
    return color_start, color_end


def print_error(error_message, error_info=""):
    """Print the `error_message` with additional `error_info`"""
    color_start, color_end = adapted_color_for_output(TERMINAL_ERROR_COLOR,
                                                      TERMINAL_RESET_COLOR)

    error_message = color_start + "ERROR: " + error_message + color_end
    if len(error_info) > 0:
        error_message = error_message + "\n" + error_info
    print(error_message)


def print_info(info_message):
    """Print the `warning_message` with additional `warning_info`"""
    color_start, color_end = adapted_color_for_output(TERMINAL_INFO_COLOR,
                                                      TERMINAL_RESET_COLOR)

    info_message = color_start + "INFO: " + info_message + color_end
    print(info_message)


def print_debug(debug_message):
    """`print_info` `debug_message` if `DEBUG` is True."""
    if DEBUG:
        print_info(debug_message)


def to_variable_name(class_name):
    return "".join(c.lower() if i == 0 else c
                   for i, c in enumerate(class_name))


def main(args):
    parser = argparse.ArgumentParser(
        description=__doc__, formatter_class=argparse.RawTextHelpFormatter)
    parser.add_argument(
        'parts',
        nargs='+',
        help='list parts to generate: all [c]oordinator [m]ediator '
        '[mu]tator [pres]entation_delegate [conf]iguration '
        'coordinator_[d]elegate [cons]umer [v]iew_controller')
    parser.add_argument("--cm", help="Coordinator/Mediator prefix", default="")
    parser.add_argument("--vc", help="ViewController prefix", default="")
    parser.add_argument("--out", help="The destination dir", default=".")
    args = parser.parse_args()

    coordinator = ("all" in args.parts or "c" in args.parts
                   or "coordinator" in args.parts)
    mediator = ("all" in args.parts or "m" in args.parts
                or "mediator" in args.parts)
    mutator = ("all" in args.parts or "mu" in args.parts
               or "mutator" in args.parts)
    presentation_delegate = ("all" in args.parts or "pres" in args.parts
                             or "presentation_delegate" in args.parts)
    configuration = ("all" in args.parts or "conf" in args.parts
                     or "configuration" in args.parts)
    coordinator_delegate = ("all" in args.parts or "d" in args.parts
                            or "coordinator_delegate" in args.parts)
    consumer = ("all" in args.parts or "cons" in args.parts
                or "consumer" in args.parts)
    view_controller = ("all" in args.parts or "v" in args.parts
                       or "view_controller" in args.parts)

    out_path = args.out
    coordinator_prefix = args.cm
    vc_prefix = args.vc

    if not os.path.exists(out_path):
        print_info(f"creating folder: {out_path}")
        os.makedirs(out_path)

    # Object class names.
    coordinator_name = f"{coordinator_prefix}Coordinator"
    coordinator_delegate_name = f"{coordinator_prefix}CoordinatorDelegate"
    configuration_name = f"{coordinator_prefix}Configuration"
    mediator_name = f"{coordinator_prefix}Mediator"

    vc_name = f"{vc_prefix}ViewController"
    vc_presentation_delegate_name = f"{vc_prefix}PresentationDelegate"
    vc_consumer_name = f"{vc_prefix}Consumer"
    vc_mutator_name = f"{vc_prefix}Mutator"

    # File names.
    coordinator_snake_name = SNAKE_CASE_RE.sub("_", coordinator_prefix).lower()
    vc_snake_name = SNAKE_CASE_RE.sub("_", vc_prefix).lower()

    coordinator_h = os.path.join(out_path,
                                 f"{coordinator_snake_name}_coordinator.h")
    coordinator_mm = os.path.join(out_path,
                                  f"{coordinator_snake_name}_coordinator.mm")
    coordinator_delegate_h = os.path.join(
        out_path, f"{coordinator_snake_name}_coordinator_delegate.h")
    configuration_h = os.path.join(
        out_path, f"{coordinator_snake_name}_configuration.h")
    configuration_mm = os.path.join(
        out_path, f"{coordinator_snake_name}_configuration.mm")
    mediator_h = os.path.join(out_path, f"{coordinator_snake_name}_mediator.h")
    mediator_mm = os.path.join(out_path,
                               f"{coordinator_snake_name}_mediator.mm")

    vc_h = os.path.join(out_path, f"{vc_snake_name}_view_controller.h")
    vc_mm = os.path.join(out_path, f"{vc_snake_name}_view_controller.mm")
    vc_presentation_delegate_h = os.path.join(
        out_path, f"{vc_snake_name}_presentation_delegate.h")
    vc_consumer_h = os.path.join(out_path, f"{vc_snake_name}_consumer.h")
    vc_mutator_h = os.path.join(out_path, f"{vc_snake_name}_mutator.h")

    # BUILD.gn data
    cm_source_set_files = []
    vc_source_set_files = []
    cm_source_set_deps = ["//base"]
    vc_source_set_deps = ["//ui/base"]
    build_gn = os.path.join(out_path, "BUILD.gn")

    # Coordinator h and mm files
    if (coordinator or presentation_delegate or configuration
            or coordinator_delegate):
        cm_source_set_deps.append("//ios/chrome/browser/shared/coordinator/"
                                  "chrome_coordinator")
        cm_source_set_files.append(f"{coordinator_snake_name}_coordinator.h")
        cm_source_set_files.append(f"{coordinator_snake_name}_coordinator.mm")

        wanted_imports = {
            '#import "ios/chrome/browser/shared/coordinator/'
            'chrome_coordinator/chrome_coordinator.h"',
        }
        if presentation_delegate:
            wanted_imports.add(f'#import "{vc_presentation_delegate_h}"')

        wanted_forwards = set()
        if configuration:
            wanted_forwards.add(f"@class {configuration_name};")
        if coordinator_delegate:
            wanted_forwards.add(f"@protocol {coordinator_delegate_name};")

        wanted_obj_type_protocols = set()
        if presentation_delegate:
            wanted_obj_type_protocols.add(vc_presentation_delegate_name)

        wanted_properties = {}
        if coordinator_delegate:
            wanted_properties[f"id<{coordinator_delegate_name}>"] = (
                "(nonatomic, weak)",
                "delegate",
            )

        if configuration:
            wanted_methods = [
                "- (instancetype)initWithBaseViewController:"
                "(UIViewController*)viewController"
                " browser:(Browser*)browser"
                f"  configuration:({configuration_name}*)configuration"
                " NS_DESIGNATED_INITIALIZER;\n",
                "- (instancetype)initWithBaseViewController:"
                "(UIViewController*)viewController"
                " browser:(Browser*)browser NS_UNAVAILABLE;\n",
            ]
        else:
            wanted_methods = [
                "- (instancetype)initWithBaseViewController:"
                "(UIViewController*)viewController"
                " browser:(Browser*)browser NS_DESIGNATED_INITIALIZER;"
            ]

        update_h_file(
            coordinator_h,
            "interface",
            coordinator_name,
            "ChromeCoordinator",
            wanted_imports,
            wanted_forwards,
            wanted_obj_type_protocols,
            wanted_properties,
            wanted_methods,
        )

        wanted_imports = {
            f'#import "{coordinator_h}"',
        }
        if mediator:
            wanted_imports.add(f'#import "{mediator_h}"')
        if view_controller:
            wanted_imports.add(f'#import "{vc_h}"')

        wanted_ivars = {}
        if mediator:
            wanted_ivars["_mediator"] = f"{mediator_name}*"
        if view_controller:
            wanted_ivars["_viewController"] = f"{vc_name}*"
        if configuration:
            wanted_ivars["_configuration"] = f"__strong {configuration_name}*"

        wanted_methods = {}
        if configuration:
            wanted_methods["-"] = {
                f"- (instancetype)initWithBaseViewController:"
                f"(UIViewController*)viewController browser:(Browser*)browser "
                f"configuration:({configuration_name}*)configuration":
                "self = [super initWithBaseViewController:viewController "
                "browser:browser];\n"
                "if (self) {\n"
                "    _configuration = configuration;\n"
                "}\n"
                " return self;\n"
            }
        else:
            wanted_methods["-"] = {
                f"- (instancetype)initWithBaseViewController:"
                f"(UIViewController*)viewController browser:(Browser*)browser":
                "self = [super initWithBaseViewController:viewController "
                "browser:browser];\n"
                "if (self) {\n"
                "}\n"
                " return self;\n"
            }
        start_parts = []
        if mediator:
            start_parts.append(f"_mediator = [[{mediator_name} alloc] "
                               "initWithSomething:@\"something\"];")
        if view_controller:
            start_parts.append(f"_viewController = [[{vc_name} alloc] init];")
        if view_controller and mutator and mediator:
            start_parts.append(f"_viewController.mutator = _mediator;")
        if view_controller and presentation_delegate:
            start_parts.append(
                f"_mediator.{to_variable_name(vc_consumer_name)}"
                f" = _viewController;")
        stop_parts = []
        if mediator:
            stop_parts.append(f"[_mediator disconnect];")
            stop_parts.append(f"_mediator = nil;")
        if view_controller:
            stop_parts.append(f"[_viewController "
                              "willMoveToParentViewController:nil];")
            stop_parts.append(f"[_viewController "
                              "removeFromParentViewController];")
            stop_parts.append(f"_viewController = nil;")

        wanted_methods["ChromeCoordinator"] = {
            "- (void)start": "\n".join(start_parts),
            "- (void)stop": "\n".join(stop_parts),
        }

        if presentation_delegate:
            wanted_methods[f"{vc_presentation_delegate_name}"] = {
                f"- (void){to_variable_name(vc_name)}:({vc_name}*)"
                f"viewController dismissedAnimated:(BOOL)animated":
                "// TODO(crbug"
                ".com/_BUG_): do dismiss animated or remove."
            }

        update_mm_file(
            coordinator_mm,
            coordinator_name,
            wanted_imports,
            wanted_ivars,
            wanted_methods,
        )

    # Presentation delegate h file
    if presentation_delegate or view_controller:
        vc_source_set_files.append(f"{vc_snake_name}_presentation_delegate.h")

        wanted_imports = {"#import <Foundation/Foundation.h>"}
        wanted_forwards = {f"@class {vc_name};"}
        wanted_obj_type_protocols = set()
        wanted_properties = {}
        wanted_methods = [
            f"// Called when the user dismisses the VC.\n"
            f"- (void){to_variable_name(vc_name)}:({vc_name}*)viewController"
            f" dismissedAnimated:(BOOL)animated;\n"
        ]

        update_h_file(
            vc_presentation_delegate_h,
            "protocol",
            vc_presentation_delegate_name,
            None,
            wanted_imports,
            wanted_forwards,
            wanted_obj_type_protocols,
            wanted_properties,
            wanted_methods,
        )

    # Coordinator configuration h and mm files
    if configuration:
        cm_source_set_files.append(f"{coordinator_snake_name}_configuration.h")
        cm_source_set_files.append(
            f"{coordinator_snake_name}_configuration.mm")

        wanted_imports = set()
        wanted_imports.add("#import <Foundation/Foundation.h>")
        wanted_forwards = set()
        wanted_obj_type_protocols = set()
        wanted_properties = {}
        wanted_methods = []

        update_h_file(
            configuration_h,
            "interface",
            configuration_name,
            "NSObject",
            wanted_imports,
            wanted_forwards,
            wanted_obj_type_protocols,
            wanted_properties,
            wanted_methods,
        )

        wanted_imports = {
            f'#import "{configuration_h}"',
        }
        wanted_ivars = {}
        wanted_methods = {}

        update_mm_file(
            configuration_mm,
            configuration_name,
            wanted_imports,
            wanted_ivars,
            wanted_methods,
        )

    # Coordinator delegate h file
    if coordinator_delegate or coordinator:
        cm_source_set_files.append(f"{coordinator_snake_name}"
                                   "_coordinator_delegate.h")

        wanted_imports = set()
        wanted_imports.add("#import <Foundation/Foundation.h>")
        wanted_forwards = set()
        wanted_forwards.add(f"@class {coordinator_name};")
        wanted_obj_type_protocols = set()
        wanted_obj_type_protocols.add("NSObject")
        wanted_properties = {}
        wanted_methods = []

        update_h_file(
            coordinator_delegate_h,
            "protocol",
            coordinator_delegate_name,
            None,
            wanted_imports,
            wanted_forwards,
            wanted_obj_type_protocols,
            wanted_properties,
            wanted_methods,
        )

    # Mediator h and mm files
    if mediator or mutator or consumer:
        cm_source_set_files.append(f"{coordinator_snake_name}_mediator.h")
        cm_source_set_files.append(f"{coordinator_snake_name}_mediator.mm")

        wanted_imports = set()
        wanted_imports.add("#import <Foundation/Foundation.h>")
        if mutator:
            wanted_imports.add(f'#import "{vc_mutator_h}"')

        wanted_forwards = set()
        if consumer:
            wanted_forwards.add(f"@protocol {vc_consumer_name};")

        wanted_obj_type_protocols = set()
        if mutator:
            wanted_obj_type_protocols.add(vc_mutator_name)

        wanted_properties = {}
        if consumer:
            wanted_properties[f"id<{vc_consumer_name}>"] = (
                "(nonatomic, weak)",
                to_variable_name(vc_consumer_name),
            )

        wanted_methods = [
            "- (instancetype)initWithSomething:(NSString*)something"
            " NS_DESIGNATED_INITIALIZER;\n",
            "- (instancetype)init NS_UNAVAILABLE;\n\n",
            "- (void)disconnect;\n",
        ]

        update_h_file(
            mediator_h,
            "interface",
            mediator_name,
            "NSObject",
            wanted_imports,
            wanted_forwards,
            wanted_obj_type_protocols,
            wanted_properties,
            wanted_methods,
        )

        wanted_imports = {
            f'#import "{mediator_h}"',
        }
        if consumer:
            wanted_imports.add(f'#import "{vc_consumer_h}"')

        wanted_ivars = {"_something": "NSString*"}

        wanted_methods = {}

        wanted_methods["-"] = {
            f"- (instancetype)initWithSomething:(NSString*)something":
            "self = [super init];\n"
            "if (self) {\n"
            "  _something = something;\n"
            "}\n"
            "return self;\n",
        }

        if consumer:
            wanted_methods["Properties getters/setters"] = {
                f"- (void)set{vc_consumer_name}:(id<{vc_consumer_name}>)"
                "consumer":
                f"_{to_variable_name(vc_consumer_name)} = consumer;\n"
                f"[_{to_variable_name(vc_consumer_name)} "
                f"setAnotherSomething:_something];\n",
            }

        wanted_methods["Public"] = {
            "- (void)disconnect": "_something = nil;\n",
        }

        update_mm_file(
            mediator_mm,
            mediator_name,
            wanted_imports,
            wanted_ivars,
            wanted_methods,
        )

    # Consumer h file
    if consumer:
        vc_source_set_files.append(f"{vc_snake_name}_consumer.h")

        wanted_imports = set()
        wanted_imports.add("#import <Foundation/Foundation.h>")
        wanted_forwards = set()
        wanted_obj_type_protocols = set()
        wanted_properties = {}
        wanted_methods = [
            "// Called when the the data model has a new something.\n"
            "- (void)setAnotherSomething:(NSString*)something;\n"
        ]

        update_h_file(
            vc_consumer_h,
            "protocol",
            vc_consumer_name,
            None,
            wanted_imports,
            wanted_forwards,
            wanted_obj_type_protocols,
            wanted_properties,
            wanted_methods,
        )

    # Mutator h file
    if mutator:
        vc_source_set_files.append(f"{vc_snake_name}_mutator.h")

        wanted_imports = set()
        wanted_imports.add("#import <Foundation/Foundation.h>")
        wanted_forwards = set()
        wanted_obj_type_protocols = set()
        wanted_properties = {}
        wanted_methods = []

        update_h_file(
            vc_mutator_h,
            "protocol",
            vc_mutator_name,
            None,
            wanted_imports,
            wanted_forwards,
            wanted_obj_type_protocols,
            wanted_properties,
            wanted_methods,
        )

    # View controller h and mm files
    if view_controller or consumer or mutator or presentation_delegate:
        vc_source_set_files.append(f"{vc_snake_name}_view_controller.h")
        vc_source_set_files.append(f"{vc_snake_name}_view_controller.mm")

        wanted_imports = {
            "#import <UIKit/UIKit.h>",
        }
        if consumer:
            wanted_imports.add(f'#import "{vc_consumer_h}"')
        if mutator:
            wanted_imports.add(f'#import "{vc_mutator_h}"')

        wanted_forwards = set()
        if coordinator_delegate:
            wanted_forwards.add(f"@protocol {vc_presentation_delegate_name};")

        wanted_obj_type_protocols = set()
        if consumer:
            wanted_obj_type_protocols.add(vc_consumer_name)

        wanted_properties = {}
        if mutator:
            wanted_properties[f"id<{vc_mutator_name}>"] = (
                "(nonatomic, weak)",
                "mutator",
            )
        if presentation_delegate:
            wanted_properties[f"id<{vc_presentation_delegate_name}>"] = (
                "(nonatomic, weak)",
                "presentationDelegate",
            )

        wanted_methods = [
            "- (instancetype)init NS_DESIGNATED_INITIALIZER;\n",
            "- (instancetype)initWithCoder:(NSCoder*)coder NS_UNAVAILABLE;\n",
            "- (instancetype)initWithNibName:(NSString*)nibNameOrNil",
            " bundle:(NSBundle*)nibBundleOrNil NS_UNAVAILABLE;\n",
        ]

        update_h_file(
            vc_h,
            "interface",
            vc_name,
            "UIViewController",
            wanted_imports,
            wanted_forwards,
            wanted_obj_type_protocols,
            wanted_properties,
            wanted_methods,
        )

        wanted_imports = {
            f'#import "{vc_h}"',
        }
        if consumer:
            wanted_imports.add(f'#import "{vc_consumer_h}"')
        if presentation_delegate:
            wanted_imports.add(f'#import "{vc_presentation_delegate_h}"')

        wanted_ivars = {}
        wanted_methods = {}

        wanted_methods["-"] = {
            "- (instancetype)init":
            "self = [super initWithNibName:nil bundle:nil];\n"
            "if (self) {\n"
            "}\n"
            "return self;\n",
        }

        wanted_methods["UIViewController"] = {
            "- (void)viewDidLoad":
            "[super viewDidLoad];\n"
            "// TODO(crbug"
            ".com/_BUG_): setup;\n",
        }

        if consumer:
            wanted_methods[f"{vc_consumer_name}"] = {
                "- (void)setAnotherSomething:(NSString*)something": "",
            }

        update_mm_file(
            vc_mm,
            vc_name,
            wanted_imports,
            wanted_ivars,
            wanted_methods,
        )

    # Create or update BUILD.gn file
    if len(vc_source_set_files):
        cm_source_set_deps.append(f":{vc_snake_name}")

    wanted_source_sets = {}
    if len(cm_source_set_files):
        wanted_source_sets[coordinator_snake_name] = {
            "sources": cm_source_set_files,
            "deps": cm_source_set_deps,
            "frameworks": ["UIKit.framework"],
        }
    if len(cm_source_set_files):
        wanted_source_sets[vc_snake_name] = {
            "sources": vc_source_set_files,
            "deps": vc_source_set_deps,
            "frameworks": ["UIKit.framework"],
        }

    if len(wanted_source_sets):
        update_build_file(build_gn, wanted_source_sets)


def update_build_file(filename, wanted_source_sets):
    """Updates or creates a build file of given`filename` with the content
    request in dictionary `wanted_source_sets`. The dictionary contains keys to
    lists for array elements of BUILD.gn (sources, deps, frameworks)"""
    print_info(filename)

    if not os.path.isfile(filename):
        subprocess.check_call(["tools/boilerplate.py", filename])

    surface_first_line = -1

    found_source_sets = []
    source_set = None

    with open(filename, "r") as body:
        all_lines = body.readlines()

        currently_in = [filename, "license"]

        for line_index, line in enumerate(all_lines):
            if currently_in[-1] == "license":
                if line[0] == "#":
                    continue
                currently_in.pop()
                surface_first_line = line_index
                # fallthrough

            if currently_in[-1] == "source_set":
                if GN_SOURCE_SET_END_RE.search(line):
                    source_set["last_line"] = line_index + 1
                    currently_in.pop()
                    continue
                match = GN_BLOCK_ONE_LINE_RE.search(line)
                if match:
                    block = match.groups()[0]
                    item = match.groups()[1]
                    source_set[f"{block}_first_line"] = line_index
                    source_set[f"{block}_last_line"] = line_index + 1
                    source_set[block].append(item)
                    source_set["block_order"].append(block)
                    continue
                match = GN_BLOCK_START_RE.search(line)
                if match:
                    block = match.groups()[0]
                    source_set[f"{block}_first_line"] = line_index
                    source_set["block_order"].append(block)
                    currently_in.append(block)
                continue

            if currently_in[-1] == "sources" or currently_in[
                    -1] == "deps" or currently_in[-1] == "frameworks":
                block = currently_in[-1]
                if GN_BLOCK_END_RE.search(line):
                    source_set[f"{block}_last_line"] = line_index + 1
                    currently_in.pop()
                    continue
                match = GN_ITEM_RE.search(line)
                if match:
                    source_set[block].append(match.groups()[0])
                    continue

            match = GN_SOURCE_SET_START_RE.search(line)
            if match:
                source_set = {
                    "name": match.groups()[0],
                    "first_line": line_index,
                    "last_line": -1,
                    "sources": [],
                    "sources_first_line": len(all_lines),
                    "sources_last_line": -1,
                    "deps": [],
                    "deps_first_line": len(all_lines),
                    "deps_last_line": -1,
                    "frameworks": [],
                    "frameworks_first_line": len(all_lines),
                    "frameworks_last_line": -1,
                    "block_order": []
                }
                found_source_sets.append(source_set)
                currently_in.append("source_set")
                continue

        # Remove items already in any existing source set
        for block in ['sources']:
            existing_items = set()
            for source_set in found_source_sets:
                for source in source_set[block]:
                    existing_items.add(source)

            for source_set, content in wanted_source_sets.items():
                new_items = []
                for source in content[block]:
                    if source not in existing_items:
                        new_items.append(source)
                content[block] = new_items

        # Remove items in matching source set
        for block in ['deps', 'frameworks']:
            for source_set in found_source_sets:
                if source_set["name"] in wanted_source_sets:
                    wanted_source_set = wanted_source_sets[source_set["name"]]
                    existing_items = set(source_set[block])
                    new_items = []
                    for source in wanted_source_set[block]:
                        if source not in existing_items:
                            new_items.append(source)
                    wanted_source_set[block] = new_items

        print_debug(f"surface: {surface_first_line}")
        print_debug(f"found_source_sets: {found_source_sets}")
        print_debug(f"wanted_source_sets: {wanted_source_sets}")

        # rewrite
        content = []
        changed = False
        cursor = 0

        # Copy until surface start.
        while cursor < len(all_lines) and cursor < surface_first_line:
            content += [all_lines[cursor]]
            cursor += 1

        # Update existing source sets
        for source_set in found_source_sets:
            name = source_set["name"]
            # Copy until first line inside source_set start.
            while (cursor < len(all_lines) and
                   cursor < source_set["first_line"] + 1):
                content += [all_lines[cursor]]
                cursor += 1
            if name in wanted_source_sets:
                wanted_source_set = wanted_source_sets[name]
                # Update existing source set, following block_order
                for block in source_set["block_order"]:
                    if len(wanted_source_set[block]) == 0:
                        continue
                    print_info(f"  updating {name}:{block}")
                    first_line = source_set[f"{block}_first_line"]
                    last_line = source_set[f"{block}_last_line"]
                    # Copy until block start.
                    while cursor < len(all_lines) and cursor < first_line:
                        content += [all_lines[cursor]]
                        cursor += 1
                    # rewrite
                    content += [f"  {block} = [\n"]
                    items = set(source_set[block]).union(
                        wanted_source_set[block])
                    for item in items:
                        content += [f'    "{item}",\n']
                    content += [f"  ]\n"]
                    # Skip lines until end of block
                    cursor = last_line
                    changed = True
                # Add other blocks that are in wanted_source_set.
                for block, items in wanted_source_set.items():
                    if block not in source_set["block_order"]:
                        print_info(f"  adding {name}:{block}")
                        content += [f"  {block} = [\n"]
                        for item in items:
                            content += [f'    "{item}",\n']
                        content += [f"  ]\n"]
                        changed = True
                del wanted_source_sets[name]

        # copy remaining lines
        while cursor < len(all_lines):
            content += [all_lines[cursor]]
            cursor += 1
        content += ["\n"]

        # Add remaining source sets
        for name, source_set in wanted_source_sets.items():
            if len(source_set["sources"]) == 0:
                continue
            print_info(f"  adding {name}")
            content += [f'source_set("{name}") {{\n']
            for block, items in source_set.items():
                content += [f"  {block} = [\n"]
                for item in items:
                    content += [f'    "{item}",\n']
                content += [f"  ]\n"]
            content += ["}\n\n"]
            changed = True

        if not changed:
            print_info(" nothing to do")
            return

        with open(filename, "w") as output:
            output.write("".join(content))

        subprocess.check_call(["gn", "format", filename])


def update_mm_file(
    filename,
    type_name,
    wanted_imports,
    wanted_ivars,
    wanted_methods,
):
    """Creates or updates a objc mm file with `filename`.
    Inserts or adds (in a sorted fashion) all #import pre-processor lines in
    the sets of `wanted_imports`, all ivars and methods in `wanted_ivars` in
    `wanted_methods` to the implementation of class with `type_name`
    Note: Methods are not sorted, but are added at the end of the specified
    section. Sections in the code are determined by `#pragma mark` tags."""

    print_info(filename)

    if not os.path.isfile(filename):
        subprocess.check_call(["tools/boilerplate.py", filename])

    with open(filename, "r") as body:
        all_lines = body.readlines()

        currently_in = [filename, "license"]
        surface_first_line = -1
        import_first_line = len(all_lines)
        import_last_line = -1
        implementation_head_first_line = len(all_lines)
        ivars_first_line = len(all_lines)
        ivars_last_line = -1
        implementation_head_last_line = -1
        implementation_last_line = -1

        found_sections = {}
        found_methods = {}
        found_imports = set()
        found_ivars = {}

        signature = ""

        section = "-"

        skip_lines = 0
        for line_index, line in enumerate(all_lines):
            if skip_lines > 0:
                skip_lines = skip_lines - 1
                continue

            if currently_in[-1] == "license":
                if line.startswith("//"):
                    continue
                else:
                    surface_first_line = line_index
                    currently_in.pop()
                    # fall through

            if currently_in[-1] == "objc_block_ignore":
                if END_RE.search(line):
                    currently_in.pop()
                    continue

            if currently_in[-1] == "ivars":
                match = IVARS_RE.search(line)
                if match:
                    found_ivars[match.groups()[1]] = match.groups()[0]
                    ivars_first_line = min(line_index, ivars_first_line)
                if IMPLEMENTATION_BLOCK_END_RE.search(line):
                    ivars_last_line = line_index
                    implementation_head_last_line = line_index + 1
                    found_sections[section] = {'first_line': line_index + 1}
                    currently_in.pop()
                continue

            if currently_in[-1] == "implementation":
                match = PRAGMA_MARK_RE.search(line)
                if match:
                    found_sections[section]['last_line'] = line_index
                    section = match.groups()[1]
                    found_sections[section] = {'first_line': line_index + 1}
                elif END_RE.search(line):
                    found_sections[section]['last_line'] = line_index
                    implementation_last_line = line_index
                    currently_in.pop()
                elif METHOD_START_RE.search(line):
                    current_line = line
                    index = 0
                    next_line = all_lines[line_index + 1]
                    multiline = current_line.strip()
                    while not current_line.strip()[-1] == "{":
                        separator = '' if multiline[-1] == ':' else ' '
                        multiline = multiline + separator + next_line.strip()
                        index = index + 1
                        current_line = next_line
                        next_line = all_lines[line_index + index + 1]
                    skip_lines = index
                    match = METHOD_HEAD_MM_RE.match(multiline)
                    if match:
                        signature = match.groups()[0].strip()
                        found_methods[signature] = {
                            "section": section,
                            "header_first_line": line_index,
                            "body_first_line": line_index + index + 1,
                        }
                        currently_in.append("method")
                continue

            if currently_in[-1] == "method":
                if IMPLEMENTATION_BLOCK_END_RE.search(line):
                    found_methods[signature]["body_last_line"] = line_index + 1
                    currently_in.pop()
                continue

            if IMPORT_RE.search(line):
                import_first_line = min(line_index, import_first_line)
                import_last_line = max(line_index + 1, import_last_line)
                found_imports.add(line.strip())
                continue

            match = IMPLEMENTATION_HEAD_RE.search(line)
            if match:
                if match.groups()[0] != type_name:
                    currently_in.append("objc_block_ignore")
                    continue
                implementation_head_first_line = line_index
                implementation_head_last_line = line_index + 1
                currently_in.append("implementation")
                if match.groups()[1] == "{":
                    currently_in.append("ivars")
                else:
                    found_sections[section] = {'first_line': line_index + 1}
                continue

        new_imports = wanted_imports.difference(found_imports)
        new_ivars = dict(wanted_ivars)
        for ivar in found_ivars:
            if ivar in new_ivars:
                del new_ivars[ivar]

        # For all methods wanted, remove them in any section where they exist.
        new_methods = {}
        if len(wanted_methods):
            for section, methods in wanted_methods.items():
                new_section = {}
                for signature, value in methods.items():
                    if signature not in found_methods:
                        new_section[signature] = value
                if len(new_section):
                    new_methods[section] = new_section

        print_debug(f"surface: {surface_first_line + 1}")
        print_debug(f"import: {import_first_line + 1} -"
                    f" {import_last_line + 1}")
        if len(new_imports):
            print_debug(f"  new_imports: {new_imports}")
        print_debug(
            f"implementation head: {implementation_head_first_line + 1}"
            f" - {implementation_head_last_line + 1}")
        print_debug(f"implementation: - {implementation_last_line + 1}")
        print_debug(f"ivars: {ivars_first_line + 1} -"
                    f" {ivars_last_line + 1}")
        if len(found_ivars):
            print_debug(f"  {found_ivars}")
        if len(new_ivars):
            print_debug(f"  new_ivars: {new_ivars}")
        print_debug("sections:")
        for section, value in found_sections.items():
            print_debug(f"  '{section}': {value['first_line'] + 1} - "
                        f"{value['last_line'] + 1}")
        print_debug("methods:")
        for signature, value in found_methods.items():
            print_debug(f"  '{signature}': {value}")
        if len(new_methods):
            print_debug(f"  new_methods: {new_methods}")

        # rewrite
        content = []
        changed = False
        cursor = 0

        # Copy until surface start.
        while cursor < len(all_lines) and cursor < surface_first_line:
            content += [all_lines[cursor]]
            cursor += 1

        # Imports.
        if len(new_imports) > 0:
            if import_first_line > import_last_line:
                print_info(" adding import section")
                if content[-1] != "\n":
                    content += ["\n"]
                sorted_imports = list(new_imports)
                sorted_imports.sort()
                for new_import in sorted_imports:
                    content += [f"{new_import}\n"]
                changed = True
            else:
                # Copy until imports start.
                while cursor < len(all_lines) and cursor < import_first_line:
                    content += all_lines[cursor]
                    cursor += 1

                # Insert missing imports if and where needed.
                print_info(" merging import section")
                while cursor < import_last_line:
                    line = all_lines[cursor].strip()
                    sorted_imports = list(new_imports)
                    sorted_imports.sort()
                    for new_import in sorted_imports:
                        if new_import < line:
                            content += [f"{new_import}\n"]
                            changed = True
                            new_imports.remove(new_import)
                    content += [all_lines[cursor]]
                    cursor += 1
                sorted_imports = list(new_imports)
                sorted_imports.sort()
                for new_import in sorted_imports:
                    content += [f"{new_import}\n"]
                    changed = True

        if implementation_head_first_line > implementation_head_last_line:
            # Copy until end.
            while cursor < len(all_lines):
                content += all_lines[cursor]
                cursor += 1

            print_info(f" adding implementation/ivars/methods sections")
            # Add Implementation header.
            content += ["\n"]
            content += [f"@implementation {type_name}"]
            # Add ivars.
            if len(new_ivars):
                content += [" {\n"]
                for ivar, type in new_ivars.items():
                    content += [f"  {type} {ivar};\n"]
                content += ["}"]
            content += ["\n\n"]

            if len(new_methods):
                content += ["\n"]
                for section, methods in new_methods.items():
                    if section != "-":
                        content += [f"#pragma mark - {section}\n\n"]
                    for signature, body in methods.items():
                        content += [f"{signature} {{\n{body}\n}}\n\n"]

            content += ["\n@end\n\n"]
            changed = True
        else:
            # Copy until implementation_head_first_line.
            while (cursor < len(all_lines)
                   and cursor < implementation_head_first_line):
                content += all_lines[cursor]
                cursor += 1

            # If ivars changed.
            if len(new_ivars):
                if ivars_first_line < ivars_last_line:
                    # Copy existing ivars
                    while cursor < len(all_lines) and cursor < ivars_last_line:
                        content += all_lines[cursor]
                        cursor += 1
                    # Add new ivars
                    for ivar, type in new_ivars.items():
                        content += [f"  {type} {ivar};\n"]
                    changed = True
                else:
                    # Copy until implementation_head_last_line.
                    while (cursor < len(all_lines)
                           and cursor < implementation_head_last_line):
                        content += all_lines[cursor]
                        cursor += 1
                    # Add new ivars.
                    content += ["{\n"]
                    for ivar, type in new_ivars.items():
                        content += [f"  {type} {ivar};\n"]
                    content += ["}\n"]
                    changed = True

            # If new methods / sections to add.
            if len(new_methods):
                for section, range in found_sections.items():
                    # Copy lines until end of section.
                    while (cursor < len(all_lines)
                           and cursor < range['last_line']):
                        content += all_lines[cursor]
                        cursor += 1
                    for method_section, methods in new_methods.items():
                        if section != method_section:
                            continue
                        for signature, body in methods.items():
                            content += [f"{signature} {{\n{body}\n}}\n\n"]
                        changed = True

                # Copy until implementation_last_line.
                while (cursor < len(all_lines)
                       and cursor < implementation_last_line):
                    content += all_lines[cursor]
                    cursor += 1
                # Add remaining sections, if any.
                for section, methods in new_methods.items():
                    if section in found_sections:
                        continue
                    if section != "-":
                        content += [f"#pragma mark - {section}\n\n"]
                    for signature, body in methods.items():
                        content += [f"{signature} {{\n{body}\n}}\n\n"]
                    changed = True

        if not changed:
            print_info(" nothing to do")
            return

        # copy remaining lines
        while cursor < len(all_lines):
            content += [all_lines[cursor]]
            cursor += 1

        with open(filename, "w") as output:
            output.write("".join(content))

        subprocess.check_call(["clang-format", "-i", filename])


def update_h_file(
    filename,
    type,
    type_name,
    type_super_name,
    wanted_imports,
    wanted_forwards,
    wanted_obj_type_protocols,
    wanted_properties,
    wanted_methods,
):
    """Creates or updates a objc header file with `filename`.
    Inserts or adds (in a sorted fashion) all #import pre-processor lines in
    the sets of `wanted_imports`, all forward declarations `wanted_forwards` in
    a sorted fashion. Inserts or updates an obj block of `type`
    (protocol or interface) with `type_name` (and with superclass
    `type_super_name` if type is interface) and with the
    `wanted_obj_type_protocols`. Inserts or adds `wanted_properties` and
    `wanted_methods`.
    Note: Properties are not sorted, new ones are added at the end."""

    print_info(filename)

    if not os.path.isfile(filename):
        subprocess.check_call(["tools/boilerplate.py", filename])

    guard = filename.upper() + "_"
    for char in "/\\.+":
        guard = guard.replace(char, "_")

    guard_start_re = re.compile(r"^#define %s" % guard)
    guard_end_re = re.compile(r"^#endif  // %s" % guard)

    with open(filename, "r") as body:
        all_lines = body.readlines()

        currently_in = [filename]
        surface_first_line = len(all_lines)
        surface_last_line = -1
        import_first_line = len(all_lines)
        import_last_line = -1
        forward_first_line = len(all_lines)
        forward_last_line = -1
        obj_type_head_first_line = len(all_lines)
        obj_type_head_last_line = -1
        obj_type_first_line = len(all_lines)
        obj_type_last_line = -1
        properties_first_line = len(all_lines)
        properties_last_line = -1
        method_first_line = len(all_lines)
        method_last_line = -1

        found_imports = set()
        found_forwards = set()
        found_obj_type_protocols = set()

        skip_lines = 0
        for line_index, line in enumerate(all_lines):
            if skip_lines > 0:
                skip_lines = skip_lines - 1
                continue

            if currently_in[-1] == "objc_block_ignore":
                if END_RE.search(line):
                    currently_in.pop()
                    continue

            if currently_in[-1] == "interface":
                if END_RE.search(line):
                    obj_type_last_line = line_index
                    currently_in.pop()
                    continue
                if METHOD_START_RE.search(line):
                    method_first_line = min(line_index, method_first_line)
                    if METHOD_H_END_RE.search(line):
                        method_last_line = max(line_index + 1,
                                               method_last_line)
                    else:
                        currently_in.append("method")
                    continue
                if PROPERTY_START_RE.search(line):
                    current_line = line
                    index = 0
                    next_line = all_lines[line_index + 1]
                    multiline = current_line
                    while (len(next_line.strip()) > 0
                           and not current_line.strip()[-1] == ";"):
                        multiline = multiline + next_line
                        index = index + 1
                        current_line = next_line
                        next_line = all_lines[line_index + index + 1]
                    skip_lines = index
                    match = PROPERTY_RE.match(multiline)
                    if match:
                        wanted_properties.pop(match.groups()[1], None)
                        properties_first_line = min(line_index,
                                                    properties_first_line)
                        properties_last_line = max(line_index + 1,
                                                   properties_last_line)
                continue

            if currently_in[-1] == "method":
                if METHOD_H_END_RE.search(line):
                    method_last_line = max(line_index + 1, method_last_line)
                    currently_in.pop()
                continue

            if guard_start_re.search(line):
                surface_first_line = line_index + 1
                currently_in.append("guard")
                continue
            if guard_end_re.search(line):
                surface_last_line = line_index
                if currently_in.pop() != "guard":
                    print_error("found unexpected h file guard:",
                                f"{line_index}: {line}")
                continue

            if IMPORT_RE.search(line):
                import_first_line = min(line_index, import_first_line)
                import_last_line = max(line_index + 1, import_last_line)
                found_imports.add(line.strip())
                continue

            if FORWARDS_RE.search(line):
                forward_first_line = min(line_index, forward_first_line)
                forward_last_line = max(line_index + 1, forward_last_line)
                found_forwards.add(line.strip())
                continue

            if OBJC_TYPE_START_RE.search(line):
                current_line = line
                index = 0
                next_line = all_lines[line_index + 1]
                multiline = current_line
                while len(next_line.strip()) > 0 and (
                        next_line.strip()[0] in ":<,"
                        or current_line.strip()[-1] in ":<,"):
                    multiline = multiline + next_line
                    index = index + 1
                    current_line = next_line
                    next_line = all_lines[line_index + index + 1]
                skip_lines = index
                match = OBJC_TYPE_RE.match(multiline)
                if (match and match.groups()[0] == type
                        and match.groups()[1] == type_name):
                    obj_type_head_first_line = line_index
                    obj_type_head_last_line = line_index + index + 1
                    obj_type_first_line = obj_type_head_last_line
                    if match.groups()[4]:
                        found_obj_type_protocols = set(
                            map(
                                lambda s: s.strip(),
                                match.groups()[4].strip("<>").split(","),
                            ))
                    currently_in.append("interface")
                else:
                    currently_in.append("objc_block_ignore")
                continue

        if surface_first_line >= surface_last_line:
            print_error("h file surface not found:")

        print_debug(f"surface: {surface_first_line + 1} -"
                    f" {surface_last_line + 1}")
        print_debug(f"import: {import_first_line + 1} -"
                    f" {import_last_line + 1}")
        print_debug(f"forward: {forward_first_line + 1} -"
                    f" {forward_last_line + 1}")
        print_debug(f"{type} head: {obj_type_head_first_line + 1} -"
                    f" {obj_type_head_last_line + 1}")
        print_debug(f"{type} body: {obj_type_first_line + 1} -"
                    f" {obj_type_last_line + 1}")
        print_debug(f"properties: {properties_first_line + 1} -"
                    f" {properties_last_line + 1}")
        print_debug(f"methods: {method_first_line + 1} -"
                    f" {method_last_line + 1}")

        # TODO: assert that if sections exist they are in the order expected.

        # rewrite
        content = []
        changed = False
        cursor = 0

        new_imports = wanted_imports.difference(found_imports)
        new_forwards = wanted_forwards.difference(found_forwards)
        obj_type_protocols = wanted_obj_type_protocols.union(
            found_obj_type_protocols)

        if len(obj_type_protocols) != len(found_obj_type_protocols):
            changed = True

        # Copy until surface start.
        while cursor < len(all_lines) and cursor < surface_first_line:
            content += [all_lines[cursor]]
            cursor += 1

        # Imports.
        if len(new_imports) > 0:
            if import_first_line > import_last_line:
                print_info(" adding import section")
                if content[-1] != "\n":
                    content += ["\n"]
                sorted_imports = list(new_imports)
                sorted_imports.sort()
                for new_import in sorted_imports:
                    content += [f"{new_import}\n"]
                changed = True
            else:
                # Copy until imports start.
                while cursor < len(all_lines) and cursor < import_first_line:
                    content += all_lines[cursor]
                    cursor += 1

                # Insert missing imports if and where needed.
                print_info(" merging import section")
                while cursor < import_last_line:
                    line = all_lines[cursor].strip()
                    sorted_imports = list(new_imports)
                    sorted_imports.sort()
                    for new_import in sorted_imports:
                        if new_import < line:
                            content += [f"{new_import}\n"]
                            changed = True
                            new_imports.remove(new_import)
                    content += [all_lines[cursor]]
                    cursor += 1
                sorted_imports = list(new_imports)
                sorted_imports.sort()
                for new_import in sorted_imports:
                    content += [f"{new_import}\n"]
                    changed = True

        # Forward declarations.
        if len(new_forwards) > 0:

            def sort_by_forward_name(s):
                return FORWARDS_RE.search(s).groups()[0]

            if forward_first_line > forward_last_line:
                print_info(" adding forward declarations section")
                if content[-1] != "\n":
                    content += ["\n"]
                sorted_forwards = list(new_forwards)
                sorted_forwards.sort(key=sort_by_forward_name)
                for new_forward in sorted_forwards:
                    content += [f"{new_forward}\n"]
                changed = True
            else:
                # Copy until forwards start.
                while cursor < len(all_lines) and cursor < forward_first_line:
                    content += all_lines[cursor]
                    cursor += 1

                # Insert missing forwards if and where needed.
                print_info(" merging forward section")
                while cursor < forward_last_line:
                    line = all_lines[cursor].strip()
                    sorted_forwards = list(new_forwards)
                    sorted_forwards.sort(key=sort_by_forward_name)
                    for new_forward in sorted_forwards:
                        if new_forward < line:
                            content += [f"{new_forward}\n"]
                            changed = True
                            new_forwards.remove(new_forward)
                    content += [all_lines[cursor]]
                    cursor += 1
                sorted_forwards = list(new_forwards)
                sorted_forwards.sort(key=sort_by_forward_name)
                for new_forward in sorted_forwards:
                    content += [f"{new_forward}\n"]
                    changed = True

        type_super = f" : {type_super_name}" if type_super_name else ""

        if obj_type_head_first_line > obj_type_head_last_line:
            # Copy until surface end.
            while cursor < len(all_lines) and cursor < surface_last_line:
                content += all_lines[cursor]
                cursor += 1

            print_info(f" adding {type}/property/methods sections")
            content += ["\n"]
            protocols_string = ""
            if len(obj_type_protocols):
                lst = list(obj_type_protocols)
                lst.sort()
                protocols_string = f"<{', '.join(lst)}>"
            content += [
                f"@{type} {type_name}{type_super} {protocols_string}"
                "\n\n"
            ]
            # Add properties.
            if len(wanted_properties):
                content += ["\n"]
                for type in wanted_properties:
                    attributes, name = wanted_properties[type]
                    content += [f"@property{attributes} {type} {name};\n\n"]
            # Add methods.
            if len(wanted_methods):
                for method in wanted_methods:
                    content += [method, "\n"]
            content += ["@end\n\n"]
            changed = True
        else:
            # Copy until type head start.
            while cursor < len(
                    all_lines) and cursor < obj_type_head_first_line:
                content += all_lines[cursor]
                cursor += 1

            if changed:
                print_info(" rewriting {type} head")

            # Rewrite interface/protocol header.
            protocols_string = ""
            if len(obj_type_protocols):
                lst = list(obj_type_protocols)
                lst.sort()
                protocols_string = f"<{', '.join(lst)}>"
            content += [
                f"@{type} {type_name}{type_super} {protocols_string}"
                "\n\n"
            ]

            # Skip existing head data
            while cursor < len(all_lines) and cursor < obj_type_head_last_line:
                cursor += 1

            # Copy existing properties
            if properties_first_line < properties_last_line:
                while cursor < len(
                        all_lines) and cursor < properties_last_line:
                    content += all_lines[cursor]
                    cursor += 1

            # Add properties.
            if len(wanted_properties):
                print_info(" adding properties section")
                content += ["\n"]
                for type in wanted_properties:
                    attributes, name = wanted_properties[type]
                    content += [f"@property{attributes} {type} {name};\n"]
                    content += ["\n"]
                changed = True

            # Add methods section if none there already.
            if method_first_line > method_last_line:
                content += ["\n"]
                if len(wanted_methods):
                    print_info(" adding methods section")
                    for methods in wanted_methods:
                        content += [methods, "\n"]
                    changed = True

        if not changed:
            print_info(" nothing to do")
            return

        # copy remaining lines
        while cursor < len(all_lines):
            content += [all_lines[cursor]]
            cursor += 1

        with open(filename, "w") as output:
            output.write("".join(content))

        subprocess.check_call(["clang-format", "-i", filename])


if __name__ == "__main__":
    sys.exit(main(sys.argv[1:]))