#!/usr/bin/env python3


import os
import sys
import json
try:
    import yaml 
    yaml_support = True
except ImportError:
    yaml_support = False
try:
    import toml
    toml_support = True
except ImportError:
    toml_support = False
    
class Str(str):
    def __write__(self, bold=False, color=37, text=''):
        if bold: 
            return f'\033[1;{color}m{text}\033[0m'
        else:
            return f'\033[{color}m{text}\033[0m'

    def black(self, bold=False):
        return self.__write__(bold=bold, color=30, text=self)
        
    def red(self, bold=False):
        return self.__write__(bold=bold, color=31, text=self)

    def green(self, bold=False):
        return self.__write__(bold=bold, color=32, text=self)

    def yellow(self, bold=False):
        return self.__write__(bold=bold, color=33, text=self)

    def blue(self, bold=False):
        return self.__write__(bold=bold, color=34, text=self)

    def purple(self, bold=False):
        return self.__write__(bold=bold, color=35, text=self)

    def cyan(self, bold=False):
        return self.__write__(bold=bold, color=36, text=self)

    def white(self, bold=False):
        return self.__write__(bold=bold, color=37, text=self)


try:
    import yaml
except ImportError:
    print(f'{Str("ERROR").red(True)}{Str(":").white(True)} YAML Is not supported (PyYAML is not installed)')


class PyCatj:

    parent = []
    
    def __init__(self, data={}):
        self._process(data)

    def _process(self, data={}):
        for key, val in data.items():
            value = False
            self.parent.append(Str(key).cyan())
            parent = self._dot().join(self.parent)
            equals = Str(':').white(True)
            if isinstance(val, dict):
                self._process(val)
            elif isinstance(val, str):
                value  = Str(val).yellow(True)
            elif isinstance(val, int):
                value  = Str(val).yellow(True)
            elif isinstance(val, (list, tuple)):
                for idx in range(len(val)):
                    i = Str(f'[{str(idx)}]').cyan()
                    v = Str(str(val[idx])).yellow(True)
                    sys.stdout.write(f'{parent}{i}{equals} {v}\n')
            if value:
                sys.stdout.write(f'{parent}{equals} {value}\n')
            self.parent.pop(len(self.parent)-1)
                
    def _dot(self):
        return Str('.').white(True)


if __name__ == '__main__':
    if len(sys.argv) > 1:
        for fname in sys.argv[1:]:
            data = False
            if os.path.isfile(fname):
                print(Str(f'Processing: {fname}').blue(True))
                if 'json' in fname:
                    data = json.loads(open(fname).read())
                elif 'yml' in fname or 'yaml' in fname and yaml_support:
                    data = yaml.load(open(fname).read(), Loader=yaml.FullLoader)
                elif 'toml' in fname or 'tml' in fname and toml_support:
                    data = toml.loads(open(fname).read())
                if data:
                    PyCatj(data)
                    print('')
    else:
        data = sys.stdin.read()
        try:
            PyCatj(json.loads(data))
            sys.exit(0)
        except json.decoder.JSONDecodeError:
            pass
        if yaml_support:
            try:
                PyCatj(yaml.load(data, Loader=yaml.FullLoader))
                sys.exit(0)
            except yaml.scanner.ScannerError:
                pass
            except yaml.parser.ParserError:
                pass
        if toml_support:
            try:
                PyCatj(toml.loads(data))
                sys.exit(0)
            except toml.decoder.TomlDecodeError:
                pass
        print(f'{Str("ERROR").red(True)}{Str(":").white(True)} Non JSON|YAML|TOML input. Sorry.')
        sys.exit(1)
