#!/usr/bin/env python
from pyaccuwage import model as pyaccuwagemodel
import argparse
import sys
import os
import re

parser = argparse.ArgumentParser(description="Check pyaccuwage record models for sequence errors.")
parser.add_argument("-i", "--input",
        nargs=1,
        required=True,
        metavar="file",
        type=argparse.FileType('r'),
        help="Source file to be checked")

args = parser.parse_args()

class ClassEntry(object):
    re_rangecomment = re.compile('#\s+(\d+)\-?(\d*)$')

    def __init__(self, classname, subclassof):
        self.classname = classname
        self.subclassof = subclassof
        self.lines = []

    def add_line(self, line):
        self.lines.append(line)

    def validate(self):
        for line in self.lines:
            match = self.re_rangecomment.search(line)
            if match:
                print match.groups()

class ModelDefParser(object):
    re_triplequote = re.compile('"""')
    re_whitespace = re.compile("^(\s*)[^\s]+")
    re_classdef = re.compile(r"^\s*class\s(.*)\((.*)\):\s*$")

    def __init__(self, infile):
        self.infile = infile

    def endclass(self):
        if self.current_class:
            self.current_class.validate()
            self.current_class = None

    def beginclass(self, classname, subclass_of):
        self.current_class = ClassEntry(classname, subclass_of)

    def parse(self):
        infile = self.infile
        whitespace = 0
        in_block_comment = False
        self.current_class = None

        for line in infile:
            if line.startswith('#'):
                continue

            if self.re_triplequote.search(line):
                in_block_comment = not in_block_comment

            if in_block_comment:
                continue

            match_whitespace = self.re_whitespace.match(line)
            if match_whitespace:
                match_whitespace = len(match_whitespace.groups()[0])
            else:
               match_whitespace = 0

            classmatch = self.re_classdef.match(line)
            if classmatch:
                classname, subclass = classmatch.groups()
                self.beginclass(classname, subclass)
                continue

            print match_whitespace
            if match_whitespace < whitespace:
                whitespace = match_whitespace
                self.endclass()
                continue

            if self.current_class:
                whitespace = match_whitespace
                self.current_class.add_line(line)

parser = ModelDefParser(args.input[0])
parser.parse()