#!/usr/bin/env python
#
# Copyright 2014 Bernard Yue
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
from __future__ import unicode_literals, absolute_import

__prog__ = 'hanzi-convert'

import os, sys, codecs
import argparse
import textwrap
import warnings
from hanziconv import HanziConv, __version__, __author__


class Main(object):
    def run(self):
        """program entry point"""
        args = self.parseArgs()
        self.args = args
        self.process(args.infile, args.outfile, args.simplified)

    def parseArgs(self):
        """parsing input arguments
        :return :       a parser.parse_arg() object
        """
        desc = textwrap.dedent("""\
                Simplified and Traditional Chinese Character Conversion
                Version {} (By {})

                Converting to Traditional Hanzi by default
                """.format(__version__, __author__))
        parser = argparse.ArgumentParser(prog=__prog__,
                formatter_class=argparse.RawDescriptionHelpFormatter,
                description=desc)
        parser.add_argument('infile', type=str,
                help='filename | "-", corresponds to stdin')
        parser.add_argument('-o', '--output', dest='outfile',
                default='',
                help='filename to save output, stdout if omitted')
        parser.add_argument('-s', '--simplified', action='store_true',
                help='convert to simplified')
        parser.add_argument('-v', '--version', action='version',
                version='%(prog)s Version ' + __version__)
        return parser.parse_args()

    def process(self, infile, outfile, simplified):
        data = self.read(infile)
        func = HanziConv.toTraditional
        if simplified:
            func = HanziConv.toSimplified
        converted = ''
        for line in data:
            converted += func(line)
        self.write(converted, outfile)

    def read(self, filename):
        """read content from filename, and stdin if filename = ''
        :return :       html as string
        """
        encoding = 'utf-8'
        with warnings.catch_warnings():
            warnings.simplefilter("ignore")
            if filename == '-':
                filename = ''

        if sys.version >= '3':
            data = self.py3GetData(filename)
        else:
            data = self.py2GetData(filename)
        return data

    def py2GetData(self, filename, encoding='utf-8'):
        """read all unicode data from file for python 2.x.  Return all data
        in `filename` as `encoding`"""
        data = ''
        if filename:
            with open(filename, 'rU') as fh:
                fh = codecs.getreader(encoding)(fh)
                data = ''.join(fh.readlines())
        else:
            sys.stdin = codecs.getreader(encoding)(sys.stdin)
            data = ''.join(sys.stdin.readlines())
        return data

    def py3GetData(self, filename, encoding='utf-8'):
        """read all unicode data from file for python 3.x.  Return all data
        in `filename` as `encoding`
        """
        data = ''
        if filename:
            with open(filename, 'r', encoding=encoding) as fh:
                data = ''.join(fh.readlines())
        else:
            data = ''.join(sys.stdin.readlines())
        return data

    def write(self, data, filename):
        """write `data` to `filename`, if 'filename` is '', write to stdout
        :return :       None
        """
        if sys.version >= '3':
            self.py3WriteData(data, filename)
        else:
            self.py2WriteData(data, filename)

    def py2WriteData(self, data, filename):
        """write unicode to file, python 2.x version"""
        if filename:
            with codecs.open(filename, 'wU', encoding='utf-8') as fh:
                fh.write(data)
        else:
            sys.stdout = codecs.getwriter("utf-8")(sys.stdout)
            sys.stdout.write(data)
            sys.stdout.flush()

    def py3WriteData(self, data, filename):
        """write unicode to file, python 3.x version"""
        if filename:
            with open(filename, 'w', encoding='utf-8') as fh:
                fh.write(data)
        else:
            sys.stdout.write(data)
            sys.stdout.flush()


if __name__ == '__main__':
    Main().run()
